Docs update

dequote and the count components are still missing

.gitignore

@@ -3,12 +3,12 @@
 # will have compiled files and executables
 debug/
 target/
-data/
 backend/debug/
 backend/target/
 frontend/debug/
 frontend/target/
 frontend/dist/
+frontend/node_modules/
 # These are backup files generated by rustfmt
 **/*.rs.bk
 
@@ -20,7 +20,7 @@ frontend/dist/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/
 
 
 # Added by cargo

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "ticketsystem"
+version = "0.1.0"
+edition = "2021"
+readme = "README.md"
+description = "A ticket system with backend and frontend components"
+publish = false
+
+[workspace]
+members = ["backend", "frontend"]
+resolver = "2"
+
+[workspace.dependencies]
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.149"
+chrono = { version = "0.4.44", features = ["serde"] }

README.md

@@ -1,2 +1,8 @@
 # Ticketsystem
 
+A ticket system with backend and frontend components.
+
+## Components
+
+- **[Backend](../backend/index.html)** - The server-side API and business logic
+- **[Frontend](../frontend/index.html)** - The client-side user interface

backend/Cargo.toml

@@ -6,12 +6,12 @@ edition = "2024"
 [dependencies]
 axum = "0.8.9"
 axum-extra = { version = "0.12.6", features = ["cookie", "typed-header", "form"] }
-serde = { version = "1.0.228", features = ["derive"] }
-serde_json = "1.0.149"
+serde = { workspace = true }
+serde_json = { workspace = true }
 sqlx = { version = "0.8.6", features = ["postgres", "runtime-tokio", "tls-native-tls", "chrono"] }
 tokio = { version = "1.52.1", features = ["rt-multi-thread", "macros"] }
 dotenv = "0.15.0"
-chrono = { version = "0.4.44", features = ["serde"] }
+chrono = { workspace = true }
 jsonwebtoken = { version = "10.3.0", features = ["rust_crypto"] }
 argon2 = "0.5.3"
 time = "0.3.47"

backend/migrations/20260422094706_ticket_table.sql

@@ -5,6 +5,6 @@ CREATE TABLE IF NOT EXISTS tickets (
     description TEXT,
     room SMALLINT,
     status VARCHAR(15) NOT NULL DEFAULT 'ToDo',
-    date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    date TIMESTAMP WITH TIME ZONE DEFAULT now(),
     user_id SMALLINT DEFAULT 1
 );

backend/migrations/20260422094717_user_table.sql

@@ -2,7 +2,13 @@ CREATE TABLE users (
     id SMALLINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
     last_name VARCHAR(30),
     first_name VARCHAR(30),
-    username VARCHAR(30),
+    username VARCHAR(30) UNIQUE,
     pwd TEXT,
     is_admin BOOLEAN NOT NULL DEFAULT false
 );
+
+INSERT INTO users(last_name, first_name, username, pwd, is_admin) VALUES ('Raffauf', 'Silas', 'raffaufsil', 
+    '$argon2id$v=19$m=19456,t=2,p=1$urV91vY49mehWQoShkm6pw$1AGLuMDuFnY1CKuQU9ed89s1u9kvuszQjX+eIXmCBKI', true);
+
+INSERT INTO users(last_name, first_name, username, pwd, is_admin) VALUES ('Misun', 'Sam', 'misunsam',
+    '$argon2id$v=19$m=19456,t=2,p=1$AMmy1zMOQG8Wg1jE5BXhDg$xhYIZPAPPOEoKQMtzWll/uhG8YJQvcpHKQU2++L23o4', true);

backend/src/cookie/jwt.rs

@@ -1,34 +1,77 @@
 use axum::{Json, http::StatusCode};
-use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
+use jsonwebtoken::{DecodingKey, EncodingKey, Header, decode, encode};
 use serde::{Deserialize, Serialize};
 
 use crate::models::Claims;
 
+/// Error response for JWT token operations.
+///
+/// Returned when token encoding or decoding fails. Used in error responses
+/// for invalid or expired tokens.
+///
+/// # Fields
+/// - `status`: HTTP status text (e.g., "error")
+/// - `message`: Human-readable error description
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Error {
     pub status: &'static str,
     pub message: String,
 }
 
+/// Encodes user information into a JSON Web Token (JWT).
+///
+/// This function creates a new JWT with the provided user ID as the subject,
+/// sets the issued-at and expiration times (60 minutes from now), and signs it
+/// using the given encoding key.
+///
+/// # Arguments
+/// - `header`: The JWT header, specifying the algorithm (e.g., HS256).
+/// - `id`: The user ID (`String`) to be embedded as the subject (`sub`) claim.
+/// - `key`: The `EncodingKey` used to sign the JWT.
+///
+/// # Returns
+/// A `String` representing the encoded JWT.
+///
+/// # Panics
+/// Panics if the token encoding fails for any reason (e.g., invalid key).
 pub fn encode_token(header: &Header, id: String, key: &EncodingKey) -> String {
     let now = chrono::Utc::now();
-    let issued = now.timestamp() as usize;
-    let expires = (now + chrono::Duration::minutes(60)).timestamp() as usize;
+    let expires = (now + chrono::Duration::minutes(60)).timestamp();
     let claims: Claims = Claims {
-        subject: id,
-        issued: issued,
-        expires: expires,
+        sub: id,
+        issued: now.timestamp() as usize,
+        expires: expires as usize,
     };
     let token = encode(header, &claims, key);
     return token.expect("token return failed");
 }
 
+/// Decodes and validates a JSON Web Token (JWT).
+///
+/// This function attempts to decode a JWT string, validate its signature and claims
+/// using the provided decoding key. It specifically ignores expiration (`validate_exp`)
+/// and "not before" (`validate_nbf`) claims during validation.
+///
+/// # Arguments
+/// - `token`: The JWT string to decode.
+/// - `key`: The `DecodingKey` used to verify the JWT's signature.
+///
+/// # Returns
+/// - `200 OK`: If the token is successfully decoded and verified, returns the extracted `Claims`.
+/// - `401 UNAUTHORIZED`: If the token is invalid, expired, or cannot be decoded,
+///   returns an `UNAUTHORIZED` status code along with a JSON error message.
 pub fn decode_token(token: String, key: &DecodingKey) -> Result<Claims, (StatusCode, Json<Error>)> {
-    let claims = decode::<Claims>(&token, key, &Validation::default())
-        .map_err(|_| {
+    let mut validation = jsonwebtoken::Validation::new(jsonwebtoken::Algorithm::HS256);
+    validation.validate_exp = false;
+    validation.validate_nbf = false;
+    validation.leeway = 0;
+
+    let claims = decode::<Claims>(&token, key, &validation)
+        .map_err(|err| {
+            let message = format!("Invalid Token: {}", err);
             let error = Error {
                 status: "error",
-                message: "Invalid Token".to_string(),
+                message,
             };
             (StatusCode::UNAUTHORIZED, Json(error))
         })?

backend/src/cookie/mod.rs

@@ -1,2 +1,7 @@
+//! This module aggregates and re-exports all cookie-related functionalities,
+//! including JWT handling and validation middleware.
+//!
+//! It serves as a central point for managing session and authentication cookies
+//! within the application.
 pub mod jwt;
 pub mod validation;

backend/src/cookie/validation.rs

@@ -12,12 +12,27 @@ use axum_extra::extract::CookieJar;
 use jsonwebtoken::DecodingKey;
 use serde_json::json;
 
-use crate::{
-    AppState,
-    cookie::jwt::decode_token,
-    models::{LoginScheme, User},
-};
+use crate::{AppState, cookie::jwt::decode_token, handlers::auth::filter_user, models::User};
 
+/// Axum middleware to validate a JWT token present in cookies or Authorization header.
+///
+/// This function extracts a JWT from the request (either from the `token` cookie or
+/// the `Authorization: Bearer` header), decodes and validates it. If valid, it fetches
+/// the corresponding user from the database and inserts a `FilteredUser` into the
+/// request extensions for subsequent handlers to use.
+///
+/// If the token is missing, invalid, or the user is not found, it returns an
+/// appropriate error response (401 Unauthorized).
+///
+/// # Arguments
+/// - `cookies`: The `CookieJar` from the request, used to extract the `token` cookie.
+/// - `request`: The incoming HTTP request, which will have user data injected into its extensions.
+/// - `next`: The next middleware or handler in the chain.
+///
+/// # Returns
+/// - `200 OK`: If validation succeeds, the request proceeds to the next handler.
+/// - `401 UNAUTHORIZED`: If validating the user fails.
+/// - `500 INTERNAL SERVER ERROR`: If the database query fails
 pub async fn validate_token(
     cookies: CookieJar,
     State(data): State<Arc<AppState>>,
@@ -53,9 +68,15 @@ pub async fn validate_token(
         token,
         &DecodingKey::from_secret(data.env.token_secret.as_ref()),
     )
-    .unwrap();
+    .map_err(|(status, json_err)| {
+        let error = json!({
+            "status": json_err.status,
+            "message": json_err.message
+        });
+        (status, Json(error))
+    })?;
 
-    let uuid = (&claims.subject).parse::<i64>().map_err(|_| {
+    let uuid = (&claims.sub).parse::<i16>().map_err(|_| {
         let error = json!({
             "status": "error",
             "message": "Invalid user id"
@@ -83,6 +104,107 @@ pub async fn validate_token(
         (StatusCode::UNAUTHORIZED, Json(error))
     })?;
 
-    request.extensions_mut().insert(user);
+    request.extensions_mut().insert(filter_user(&user));
+    Ok(next.run(request).await)
+}
+
+/// Axum middleware to validate JWT token and ensure the authenticated user has admin privileges.
+///
+/// This middleware first performs all checks of `validate_token`: extracting, decoding,
+/// and validating the JWT, and fetching the associated user from the database.
+/// Additionally, it verifies that the fetched user has `is_admin` set to `true`.
+///
+/// If the user is not authenticated or not an administrator, it returns an
+/// appropriate error response (401 Unauthorized or 403 Forbidden).
+///
+/// # Arguments
+/// - `cookies`: The `CookieJar` from the request.
+/// - `request`: The incoming HTTP request, which will have admin user data injected.
+/// - `next`: The next middleware or handler in the chain.
+///
+/// # Returns
+/// - `200 OK`: If validation and admin check succeed, the request proceeds.
+/// - `401 UNAUTHORIZED`: An error response if validation fails or the user is not an admin.
+/// - `500 INTERNAL SERVER ERROR`: If the databse query fails
+pub async fn validate_admin(
+    cookies: CookieJar,
+    State(data): State<Arc<AppState>>,
+    mut request: Request<Body>,
+    next: Next,
+) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    let token = cookies
+        .get("token")
+        .map(|cookie| cookie.value().to_string())
+        .or_else(|| {
+            request
+                .headers()
+                .get(header::AUTHORIZATION)
+                .and_then(|header| header.to_str().ok())
+                .and_then(|value| {
+                    if value.starts_with("Bearer ") {
+                        Some(value[7..].to_owned())
+                    } else {
+                        None
+                    }
+                })
+        });
+
+    let token = token.ok_or_else(|| {
+        let error = json!({
+            "status": "error",
+            "message": "Please provide a valid token"
+        });
+        (StatusCode::UNAUTHORIZED, Json(error))
+    })?;
+
+    let claims = decode_token(
+        token,
+        &DecodingKey::from_secret(data.env.token_secret.as_ref()),
+    )
+    .map_err(|(status, json_err)| {
+        let error = json!({
+            "status": json_err.status,
+            "message": json_err.message
+        });
+        (status, Json(error))
+    })?;
+
+    let uuid = (&claims.sub).parse::<i16>().map_err(|_| {
+        let error = json!({
+            "status": "error",
+            "message": "Invalid user id"
+        });
+        (StatusCode::UNAUTHORIZED, Json(error))
+    })?;
+
+    let user = sqlx::query_as::<_, User>(r#"SELECT * FROM users WHERE id = $1"#)
+        .bind(uuid)
+        .fetch_optional(&data.db)
+        .await
+        .map_err(|e| {
+            let error = json!({
+                "status": "error",
+                "message": format!("Database error: {}", e)
+            });
+            (StatusCode::INTERNAL_SERVER_ERROR, Json(error))
+        })?;
+
+    let user = user.ok_or_else(|| {
+        let error = json!({
+            "status": "error",
+            "message": "Invalid user"
+        });
+        (StatusCode::UNAUTHORIZED, Json(error))
+    })?;
+
+    if !user.is_admin {
+        let error = json!({
+            "status": "error",
+            "message": "Admin access required"
+        });
+        return Err((StatusCode::FORBIDDEN, Json(error)));
+    }
+
+    request.extensions_mut().insert(filter_user(&user));
     Ok(next.run(request).await)
 }

backend/src/env.rs

@@ -1,11 +1,37 @@
+/// Environment configuration for the application.
+///
+/// Loads required configuration from environment variables at startup.
+/// All variables must be present or the application will panic.
+///
+/// # Fields
+/// - `db_url`: PostgreSQL database connection URL.
+/// - `token_secret`: Secret key used to sign and verify JWT tokens.
+/// - `origin`: Frontend origin URL for CORS policy.
+///
+/// # Required Environment Variables
+/// - `DATABASE_URL`: PostgreSQL connection string (e.g., `postgresql://user:pass@localhost/dbname`)
+/// - `TOKEN_SECRET`: Secret key for JWT token signing (use a strong random string in production)
+/// - `ORIGIN`: Frontend URL for CORS (e.g., `http://localhost:8080`)
 #[derive(Debug, Clone)]
 pub struct Env {
+    /// PostgreSQL database connection URL
     pub db_url: String,
+    /// Secret key used to sign and verify JWT tokens
     pub token_secret: String,
+    /// Frontend origin URL for CORS policy
     pub origin: String,
 }
 
 impl Env {
+    /// Loads environment configuration from system environment variables.
+    ///
+    /// Panics if any required variable is missing.
+    ///
+    /// # Example
+    /// ```ignore
+    /// let env = Env::load();
+    /// // Environment must have DATABASE_URL, TOKEN_SECRET, and ORIGIN set
+    /// ```
     pub fn load() -> Env {
         let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
         let token_secret = std::env::var("TOKEN_SECRET").expect("TOKEN_SECRET must be set");

backend/src/handlers/auth.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, usize};
+use std::sync::Arc;
 
 use argon2::{
     Argon2, PasswordHash, PasswordHasher, PasswordVerifier,
@@ -11,7 +11,6 @@ use axum::{
     response::IntoResponse,
 };
 use axum_extra::extract::cookie::{Cookie, SameSite};
-use chrono::format;
 use jsonwebtoken::{EncodingKey, Header};
 use serde_json::json;
 
@@ -21,6 +20,26 @@ use crate::{
     models::{FilteredUser, LoginScheme, User, UserCreateScheme, UserUpdateScheme},
 };
 
+/// Registers a new user in the system.
+///
+/// Creates a new user account with the provided credentials. The password is hashed using Argon2
+/// before being stored. Only administrators can create new users.
+///
+/// # Arguments
+/// - `request`: Json with [UserCreateScheme] as it's format
+///
+/// # Returns
+/// - `200 OK` on successful user creation
+/// - `400 Bad Request` if username/password missing or user already exists
+/// - `500 Internal Server Error` if database insertion fails
+///
+/// # Password Hashing
+/// Uses Argon2 with a cryptographically secure random salt:
+/// ```ignore
+/// let argon = Argon2::default();
+/// let salt = SaltString::generate(&mut OsRng);
+/// let hashed_pwd = argon.hash_password(password.as_bytes(), &salt)?;
+/// ```
 pub async fn create_user(
     State(data): State<Arc<AppState>>,
     Json(request): Json<UserCreateScheme>,
@@ -84,6 +103,39 @@ pub async fn create_user(
     }
 }
 
+/// Authenticates a user and creates a JWT token for session management.
+///
+/// Verifies the provided username and password against stored credentials using Argon2 verification.
+/// On successful authentication, generates a JWT token and sets it as an HTTP-only cookie.
+/// The token is valid for 1 hour.
+///
+/// # Arguments
+/// - `request`: Login credentials in Json format using the [LoginScheme]
+///
+/// # Returns
+/// - `200 OK` with JSON containing token and [FilteredUser] info
+/// - `400 Bad Request` if username not found or password invalid
+/// - `500 Internal Server Error` if database query fails
+///
+/// # Security Features
+/// - HTTP-only cookie prevents JavaScript access
+/// - SameSite=Lax protects against CSRF attacks
+/// - Password verification uses Argon2:
+///   ```ignore
+///   let valid_pwd = Argon2::default()
+///       .verify_password(&request.pwd.as_bytes(), &pwd_hash.unwrap())
+///       .is_ok();
+///   ```
+/// - JWT token includes user ID and expiration timestamp
+///
+/// # Example Response
+/// ```json
+/// {
+///   "status": "success",
+///   "token": "eyJ0eXAiOiJKV1QiLCJhbGc...",
+///   "user": {"id": 1, "first_name": "Admin", "last_name": "User", "username": "admin", "is_admin": true}
+/// }
+/// ```
 pub async fn login(
     State(data): State<Arc<AppState>>,
     Json(request): Json<LoginScheme>,
@@ -139,6 +191,24 @@ pub async fn login(
     Ok(response)
 }
 
+/// Logs out the current user by invalidating their session cookie.
+///
+/// Sets the authentication cookie to expire immediately (max_age = -1 hour) which causes
+/// the browser to discard it. This effectively logs the user out without requiring server-side
+/// session invalidation.
+///
+/// # Returns
+/// Always returns `200 OK` with success message and an expired cookie header
+///
+/// # Security
+/// - HTTP-only cookie prevents client-side manipulation
+/// - SameSite=Lax protects against CSRF
+/// - Setting max_age to negative value causes immediate expiration
+///
+/// # Example Response
+/// ```json
+/// {"status": "success", "message": "successfully logged out"}
+/// ```
 pub async fn logout() -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
     let cookie = Cookie::build(("token", ""))
         .path("/")
@@ -155,20 +225,55 @@ pub async fn logout() -> Result<impl IntoResponse, (StatusCode, Json<serde_json:
     Ok(response)
 }
 
+/// Retrieves the currently authenticated user's information.
+///
+/// Uses the user data embedded in the JWT token (via middleware).
+/// Useful for frontends to display logged-in user info or verify authentication.
+///
+/// # Returns
+/// - `200 OK` with the [FilteredUser] in Json format
+/// - Automatically returns `401 Unauthorized` if not authenticated (middleware)
+///
+/// # Example Response
+/// ```json
+/// {
+///   "status": "success",
+///   "data": {
+///     "id": 1,
+///     "first_name": "Admin",
+///     "last_name": "User",
+///     "is_admin": true
+///   }
+/// }
+/// ```
 pub async fn get_current_user(
-    Extension(state): Extension<User>,
+    Extension(user): Extension<FilteredUser>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
     let response = json!({
         "status": "success",
         "data": json!({
-            "first_name": filter_user(&state).first_name,
-            "last_name": filter_user(&state).last_name
+            "id": user.id,
+            "first_name": user.first_name,
+            "last_name": user.last_name,
+            "is_admin": user.is_admin
         })
     });
 
     Ok(Json(response))
 }
 
+/// Deletes a user account from the system.
+///
+/// Only admins can delete users. The user account and all associated data is removed.
+/// Note: Tickets created by deleted users will have NULL user_id references.
+///
+/// # Arguments
+/// - `id`: User ID to delete
+///
+/// # Returns
+/// - `204 No Content` on successful deletion
+/// - `404 Not Found` if user doesn't exist
+/// - `500 Internal Server Error` if database error occurs
 pub async fn delete_user(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
@@ -195,6 +300,34 @@ pub async fn delete_user(
     Ok(StatusCode::NO_CONTENT)
 }
 
+/// Retrieves all users in the system.
+///
+/// Only admins can call this endpoint. Returns all users sorted alphabetically by last name.
+/// Password hashes are not included in the response.
+///
+/// # Returns
+/// - `200 OK` with array of [FilteredUser] objects
+/// - `500 Internal Server Error` if database query fails
+///
+/// # Example Response
+/// ```json
+/// [
+///   {
+///     "id": 1,
+///     "first_name": "Admin",
+///     "last_name": "User",
+///     "username": "admin",
+///     "is_admin": true
+///   },
+///   {
+///     "id": 2,
+///     "first_name": "Regular",
+///     "last_name": "User",
+///     "username": "regularuser",
+///     "is_admin": false
+///   }
+/// ]
+/// ```
 pub async fn get_users(
     State(data): State<Arc<AppState>>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
@@ -217,8 +350,18 @@ pub async fn get_users(
     Ok(Json(json_respnse))
 }
 
+/// Retrieves a single user's details by their ID.
+///
+/// # Arguments
+/// - `id`: The ID of the user to retrieve, extracted from the URL path.
+///
+/// # Returns
+/// - `200 OK` with a [FilteredUser] JSON object if the user is found.
+/// - `404 Not Found` if a user with the given ID does not exist.
+/// - `500 Internal Server Error` if a database query error occurs.
+///
 pub async fn get_user_by_id(
-    Path(id): Path<i32>,
+    Path(id): Path<i16>,
     State(data): State<Arc<AppState>>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
     let query = sqlx::query_as::<_, User>(r#"SELECT * FROM users WHERE id = $1"#)
@@ -247,6 +390,20 @@ pub async fn get_user_by_id(
     };
 }
 
+/// Updates an existing user's information.
+///
+/// # Arguments
+/// - `id`: The ID of the user to update, extracted from the URL path.
+/// - `body`: [UserUpdateScheme] containing the fields to update.
+///
+/// # Returns
+/// - `200 OK` with the [FilteredUser] object of the updated user.
+/// - `404 Not Found` if a user with the given ID does not exist.
+/// - `500 Internal Server Error` if a database query or password hashing error occurs.
+///
+/// # Security Note
+/// - Passwords are hashed using Argon2 before storage.
+/// - This endpoint typically requires admin privileges (enforced by middleware).
 pub async fn update_user(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
@@ -263,7 +420,7 @@ pub async fn update_user(
         .bind(body.first_name.to_owned())
         .bind(body.last_name.to_owned())
         .bind(body.username.to_owned())
-        .bind(hashed_pwd)
+        .bind(&hashed_pwd)
         .bind(body.make_admin.to_owned())
         .bind(id)
         .execute(&data.db)
@@ -302,7 +459,149 @@ pub async fn update_user(
     Ok(Json(response))
 }
 
-fn filter_user(user: &User) -> FilteredUser {
+/// Checks if any administrator user exists in the system.
+///
+/// # Returns
+/// - `200 OK` On successful database query
+/// - `500 Internal Server Error` if database query fails
+///
+/// # Example Response
+/// ```json
+/// {"has_admin": false}
+/// ```
+pub async fn check_admin_exists(
+    State(data): State<Arc<AppState>>,
+) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    let admin_count =
+        sqlx::query_scalar::<_, i64>(r#"SELECT COUNT(*) FROM users WHERE is_admin = true"#)
+            .fetch_one(&data.db)
+            .await
+            .map_err(|e| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({"status": "error", "message": format!("{:?}", e)})),
+                )
+            })?;
+
+    let has_admin = admin_count > 0;
+    Ok(Json(json!({"has_admin": has_admin})))
+}
+
+/// Creates the initial administrator account for a fresh system.
+///
+/// This function handles the one-time setup of the first admin user. It checks that no admin exists
+/// before allowing creation. This endpoint is only functional when the system has no administrators.
+/// Once created, subsequent admin registrations must go through the normal `create_user` endpoint
+/// with proper authorization.
+///
+/// # Arguments
+/// - `request`: [UserCreateScheme] as a Json value
+///
+/// # Returns
+/// - `200 OK` with success message if admin account created
+/// - `400 Bad Request` if:
+///   - Admin already exists
+///   - Username or password is empty
+/// - `500 Internal Server Error` if database insertion fails
+///
+/// # Security Note
+/// The password is hashed using Argon2 with a random salt before storage:
+/// ```ignore
+/// let argon = Argon2::default();
+/// let salt = SaltString::generate(&mut OsRng);
+/// let hashed_pwd = argon.hash_password(request.pwd.as_bytes(), &salt)?;
+/// ```
+pub async fn setup_initial_admin(
+    State(data): State<Arc<AppState>>,
+    Json(request): Json<UserCreateScheme>,
+) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    // Check if any admin already exists
+    let admin_count =
+        sqlx::query_scalar::<_, i64>(r#"SELECT COUNT(*) FROM users WHERE is_admin = true"#)
+            .fetch_one(&data.db)
+            .await
+            .map_err(|e| {
+                (
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(json!({"status": "error", "message": format!("{:?}", e)})),
+                )
+            })?;
+
+    if admin_count > 0 {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            Json(json!({"status": "error", "message": "Admin user already exists"})),
+        ));
+    }
+
+    if request.username.is_empty() || request.pwd.is_empty() {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            Json(json!({"status": "error", "message": "Missing credential"})),
+        ));
+    }
+
+    let argon = Argon2::default();
+    let salt = SaltString::generate(&mut OsRng);
+    let hashed_pwd = match argon.hash_password(request.pwd.clone().as_bytes(), &salt) {
+        Ok(h) => h.to_string(),
+        Err(e) => panic!("Error hashing {:}", e),
+    };
+
+    let user = sqlx::query("INSERT INTO users (username, pwd, first_name, last_name, is_admin) VALUES ($1, $2, $3, $4, $5)")
+        .bind(request.username)
+        .bind(&hashed_pwd)
+        .bind(request.first_name)
+        .bind(request.last_name)
+        .bind(true)
+        .execute(&data.db)
+        .await
+        .map_err(|e| {
+            (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(json!({"status": "error", "message": format!("{}", e)})),
+            )
+        })?;
+
+    if user.rows_affected() < 1 {
+        return Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(json!({"status": "error", "message": "Error creating admin user"})),
+        ));
+    } else {
+        Ok(Json(
+            json!({"status": "success", "result": "Admin user created"}),
+        ))
+    }
+}
+
+/// Converts a User with sensitive data into a FilteredUser safe for API responses.
+///
+/// This function removes password hashes and other sensitive information before
+/// returning user data to clients. Always use this helper instead of directly
+/// serializing User objects.
+///
+/// # Arguments
+/// - `user`: Reference to the internal [User] struct containing password hash
+///
+/// # Returns
+/// [FilteredUser] with only safe-to-share information:
+/// - `id`: User ID
+/// - `first_name`, `last_name`: User name
+/// - `username`: Login username
+/// - `is_admin`: Admin privilege flag
+///
+/// # Important
+/// The password hash is explicitly **NOT** included in the output. This prevents
+/// accidental exposure of sensitive authentication data.
+///
+/// # Example
+/// ```ignore
+/// let user = get_user_from_db(1).await?;
+/// let safe_user = filter_user(&user);
+/// // safe_user can be safely serialized and sent to client
+/// ```
+pub fn filter_user(user: &User) -> FilteredUser {
     FilteredUser {
         id: user.id,
         first_name: user.first_name.clone(),

backend/src/handlers/mod.rs

@@ -1,2 +1,6 @@
+//! This module aggregates and re-exports all API endpoint handler functions.
+//!
+//! It serves as a central point for managing the logic that responds to various
+//! HTTP requests, categorizing handlers by their domain (e.g., authentication, tickets).
 pub mod auth;
 pub mod ticket;

backend/src/handlers/ticket.rs

@@ -1,30 +1,49 @@
 use std::sync::Arc;
 
 use axum::{
-    Json,
+    Extension, Json,
     extract::{Path, State},
     http::StatusCode,
     response::IntoResponse,
 };
 use serde_json::json;
-use sqlx::query;
+use sqlx::{Row, query};
 
 use crate::{
     AppState,
-    models::{Ticket, TicketCreateScheme, TicketResponse, TicketUpdateScheme},
+    models::{FilteredUser, TicketCreateScheme, TicketResponse, TicketUpdateScheme},
 };
 
+/// Creates a new support ticket.
+///
+/// Associates the ticket with the authenticated user and sets the current timestamp.
+/// Tickets are automatically created with "open" status.
+///
+/// # Arguments
+/// - `user`: Authenticated user (extracted from JWT token)
+/// - `body`: Json with the [TicketCreateScheme] as it's format
+///
+/// # Returns
+/// - `200 OK` on successful creation
+/// - `500 Internal Server Error` if database insertion fails
+///
+/// # Database Fields Set Automatically
+/// - `user_id`: From authenticated user
+/// - `status`: Defaults to "open"
+/// - `date`: Current UTC timestamp
 pub async fn create_ticket(
+    Extension(user): Extension<FilteredUser>,
     State(data): State<Arc<AppState>>,
     Json(body): Json<TicketCreateScheme>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
     let query = query(
-        r#"INSERT INTO tickets (category, description, betreff, room) VALUES ($1, $2, $3, $4)"#,
+        r#"INSERT INTO tickets (category, description, betreff, room, user_id) VALUES ($1, $2, $3, $4, $5)"#,
     )
     .bind(body.category.to_string())
     .bind(body.description.to_string())
     .bind(body.betreff.to_string())
     .bind(body.room)
+    .bind(user.id)
     .execute(&data.db)
     .await;
 
@@ -39,6 +58,17 @@ pub async fn create_ticket(
     Ok(Json(response_status))
 }
 
+/// Deletes a ticket by ID.
+///
+/// Only admins can delete tickets. Marks the ticket as deleted or removes from database.
+///
+/// # Arguments
+/// - `id`: Ticket ID to delete
+///
+/// # Returns
+/// - `204 No Content` on successful deletion
+/// - `404 Not Found` if ticket doesn't exist
+/// - `500 Internal Server Error` if database error occurs
 pub async fn delete_ticket(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
@@ -65,12 +95,44 @@ pub async fn delete_ticket(
     Ok(StatusCode::NO_CONTENT)
 }
 
+/// Retrieves all tickets.
+///
+/// Returns a list of all tickets with user information denormalized for easier rendering.
+/// Tickets are ordered by creation date (newest first).
+///
+/// # Filtering
+/// - Uses LEFT JOIN to include creator information
+///
+/// # Returns
+/// - `200 OK` with array of [TicketResponse] objects
+/// - `500 Internal Server Error` if database query fails
+///
+/// # Example Response
+/// ```json
+/// [
+///   {
+///     "id": 1,
+///     "category": "maintenance",
+///     "betreff": "Broken light",
+///     "description": "Ceiling light not working",
+///     "room": 101,
+///     "status": "open",
+///     "date": "2024-01-15T10:30:00Z",
+///     "user_id": 5,
+///     "user_first_name": "John",
+///     "user_last_name": "Doe"
+///   }
+/// ]
+/// ```
 pub async fn get_tickets(
     State(data): State<Arc<AppState>>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
-    println!("get_tickets called");
-    let tickets = sqlx::query_as::<_, Ticket>(
-        r#"SELECT * FROM tickets WHERE status <> 'Archived' ORDER BY date DESC"#,
+    // Query tickets with denormalized user info, excluding archived tickets
+    let tickets = sqlx::query(
+        r#"SELECT t.id, t.category, t.betreff, t.description, t.room, t.status, t.date, t.user_id, u.first_name, u.last_name
+           FROM tickets t
+           LEFT JOIN users u ON t.user_id = u.id
+           ORDER BY t.date DESC"#,
     )
     .fetch_all(&data.db)
     .await
@@ -81,31 +143,85 @@ pub async fn get_tickets(
         });
         (StatusCode::INTERNAL_SERVER_ERROR, Json(error_response))
     })?;
-    println!("Tickets fetched");
 
-    let ticket_response = tickets
+    // Transform raw database rows into TicketResponse structs
+    let ticket_response: Vec<TicketResponse> = tickets
         .iter()
-        .map(|ticket| filter_record(&ticket))
-        .collect::<Vec<TicketResponse>>();
+        .map(|row| TicketResponse {
+            id: row.get("id"),
+            category: row.get("category"),
+            betreff: row.get("betreff"),
+            description: row.get("description"),
+            room: row.get("room"),
+            status: row.get("status"),
+            date: row.get("date"),
+            user_id: row.get("user_id"),
+            user_first_name: row.get("first_name"),
+            user_last_name: row.get("last_name"),
+        })
+        .collect();
 
     let json_response = serde_json::json!(ticket_response);
-    println!("Json contructed");
     Ok(Json(json_response))
 }
 
+/// Retrieves a specific ticket by ID.
+///
+/// Includes full ticket details and denormalized user information (creator name).
+///
+/// # Arguments
+/// - `id`: Ticket ID to retrieve
+///
+/// # Returns
+/// - `200 OK` with [TicketResponse] object
+/// - `404 Not Found` if ticket doesn't exist
+/// - `500 Internal Server Error` if database error occurs
+///
+/// # Example Response
+/// ```json
+/// {
+///   "id": 1,
+///   "category": "maintenance",
+///   "betreff": "Broken light in room 101",
+///   "description": "The ceiling light is not working",
+///   "room": 101,
+///   "status": "open",
+///   "date": "2024-01-15T10:30:00Z",
+///   "user_id": 5,
+///   "user_first_name": "John",
+///   "user_last_name": "Doe"
+/// }
+/// ```
 pub async fn get_ticket_by_id(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
-    let query = sqlx::query_as::<_, Ticket>(r#"SELECT * FROM tickets WHERE id = $1"#)
+    let query = sqlx::query(
+        r#"SELECT t.id, t.category, t.betreff, t.description, t.room, t.status, t.date, t.user_id, u.first_name, u.last_name
+           FROM tickets t
+           LEFT JOIN users u ON t.user_id = u.id
+           WHERE t.id = $1"#,
+    )
     .bind(id)
     .fetch_one(&data.db)
     .await;
 
     match query {
-        Ok(ticket) => {
-            let ticket_response = serde_json::json!(filter_record(&ticket));
-            return Ok(Json(ticket_response));
+        Ok(row) => {
+            let ticket_response = TicketResponse {
+                id: row.get("id"),
+                category: row.get("category"),
+                betreff: row.get("betreff"),
+                description: row.get("description"),
+                room: row.get("room"),
+                status: row.get("status"),
+                date: row.get("date"),
+                user_id: row.get("user_id"),
+                user_first_name: row.get("first_name"),
+                user_last_name: row.get("last_name"),
+            };
+            let response = serde_json::json!(ticket_response);
+            return Ok(Json(response));
         }
         Err(sqlx::Error::RowNotFound) => {
             let error_response = serde_json::json!({
@@ -123,11 +239,30 @@ pub async fn get_ticket_by_id(
     };
 }
 
+/// Updates a ticket's status.
+///
+/// Only admins can update ticket status. This is typically used to transition tickets
+/// through their lifecycle (open → in_progress → resolved → archived).
+///
+/// # Arguments
+/// - `id`: Ticket ID to update
+/// - `body`: Update payload as a Json array with [TicketUpdateScheme] as it's format
+///
+/// # Returns
+/// - `200 OK` with updated [TicketResponse]
+/// - `500 Internal Server Error` if ticket not found or database error
+///
+/// # Typical Status Flow
+/// - `open`: Initial state, waiting for action
+/// - `in_progress`: Currently being worked on
+/// - `resolved`: Issue fixed
+/// - `archived`: Closed/hidden from normal view
 pub async fn edit_ticket(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
     Json(body): Json<TicketUpdateScheme>,
 ) -> Result<impl IntoResponse, (StatusCode, Json<serde_json::Value>)> {
+    // Update the ticket status
     let update_result = sqlx::query(r#"UPDATE tickets SET status = $1 WHERE id = $2"#)
         .bind(body.status.to_owned())
         .bind(id)
@@ -148,7 +283,13 @@ pub async fn edit_ticket(
         return Err((StatusCode::INTERNAL_SERVER_ERROR, Json(error_response)));
     }
 
-    let updated_ticket = sqlx::query_as::<_, Ticket>(r#"SELECT * FROM tickets WHERE id = $1"#)
+    // Fetch and return the updated ticket
+    let updated_ticket = sqlx::query(
+        r#"SELECT t.id, t.category, t.betreff, t.description, t.room, t.status, t.date, t.user_id, u.first_name, u.last_name
+           FROM tickets t
+           LEFT JOIN users u ON t.user_id = u.id
+           WHERE t.id = $1"#,
+    )
     .bind(id)
     .fetch_one(&data.db)
     .await
@@ -159,23 +300,23 @@ pub async fn edit_ticket(
         )
     })?;
 
-    let ticket_response = serde_json::json!({
-        "ticket": filter_record(&updated_ticket),
+    let ticket_response = TicketResponse {
+        id: updated_ticket.get("id"),
+        category: updated_ticket.get("category"),
+        betreff: updated_ticket.get("betreff"),
+        description: updated_ticket.get("description"),
+        room: updated_ticket.get("room"),
+        status: updated_ticket.get("status"),
+        date: updated_ticket.get("date"),
+        user_id: updated_ticket.get("user_id"),
+        user_first_name: updated_ticket.get("first_name"),
+        user_last_name: updated_ticket.get("last_name"),
+    };
+
+    let response = serde_json::json!({
+        "ticket": ticket_response,
         "status": "success"
     });
 
-    Ok(Json(ticket_response))
-}
-
-fn filter_record(ticket: &Ticket) -> TicketResponse {
-    TicketResponse {
-        id: ticket.id.to_owned(),
-        category: ticket.category.to_owned(),
-        betreff: ticket.betreff.to_owned(),
-        description: ticket.description.to_owned(),
-        room: ticket.room.to_owned(),
-        status: ticket.status.to_owned(),
-        date: ticket.date.to_owned(),
-        user_id: ticket.user_id.to_owned(),
-    }
+    Ok(Json(response))
 }

backend/src/main.rs

@@ -1,38 +1,98 @@
-#![allow(unused_imports)]
+/// Cookie and JWT authentication utilities
 mod cookie;
+/// Environment configuration loading
 mod env;
+/// HTTP request handlers for all endpoints
 mod handlers;
+/// Data structures for request/response serialization
 mod models;
+/// Axum router configuration with all routes and middleware
 mod router;
-use std::sync::Arc;
+
+use std::sync::{
+    Arc,
+    atomic::{AtomicI64, Ordering},
+};
 
 use axum::{
-    Router,
+    Json,
     http::{
-        HeaderValue, Method,
+        HeaderValue, Method, StatusCode,
         header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE},
     },
-    routing,
 };
 use dotenv::dotenv;
-use models::*;
 use router::create_router;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use sqlx::{PgPool, postgres::PgPoolOptions};
 use tower_http::cors::CorsLayer;
 
 use crate::env::Env;
 
+/// A variable to count the problems fixed by a very easy solution
+static EASY_FIX_COUNT: AtomicI64 = AtomicI64::new(0);
+
+/// The Response struct for the [EASY_FIX_COUNT]
+#[derive(Serialize)]
+struct CounterResp {
+    value: i64,
+}
+
+/// Gets the [EASY_FIX_COUNT] value
+///
+/// # Returns
+/// - `200 OK` with the value on success
+async fn get_count() -> Json<CounterResp> {
+    let v = EASY_FIX_COUNT.load(Ordering::SeqCst);
+    Json(CounterResp { value: v })
+}
+
+/// Incremets the [EASY_FIX_COUNT] value by one
+///
+/// # Returns
+/// - `200 OK` with the new value on success
+async fn increment() -> Result<Json<CounterResp>, StatusCode> {
+    let new = EASY_FIX_COUNT.fetch_add(1, Ordering::SeqCst) + 1;
+    Ok(Json(CounterResp { value: new }))
+}
+
+/// Shared application state passed to all route handlers.
+///
+/// Contains the database connection pool and environment configuration.
+/// This is wrapped in Arc for thread-safe sharing across async tasks.
+///
+/// # Fields
+/// - `db`: PostgreSQL connection pool for database access
+/// - `env`: Configuration loaded from environment variables
 pub struct AppState {
     db: PgPool,
     env: Env,
 }
 
+/// Main application entry point.
+///
+/// Initializes the server by:
+/// 1. Loading environment variables from `.env` file
+/// 2. Establishing database connection pool
+/// 3. Configuring CORS policy for cross-origin requests
+/// 4. Starting HTTP server on port 8001
+///
+/// # Server Configuration
+/// - Binds to `0.0.0.0:8001` (all network interfaces)
+/// - Allows: GET, POST, PATCH, DELETE methods
+/// - Allows credentials and custom headers
+/// - CORS origin configured from environment
+///
+/// # Panics
+/// - If environment loading fails
+/// - If database connection fails
 #[tokio::main]
 async fn main() {
     dotenv().ok();
     let env = Env::load();
     let database_url = &env.db_url;
+
+    // Establish connection pool to PostgreSQL
     let pool = match PgPoolOptions::new().connect(&database_url).await {
         Ok(pool) => {
             println!("Database connection successful");
@@ -44,18 +104,21 @@ async fn main() {
         }
     };
 
+    // Configure CORS to allow requests from frontend
     let cors = CorsLayer::new()
         .allow_origin(env.origin.parse::<HeaderValue>().unwrap())
         .allow_methods([Method::GET, Method::POST, Method::PATCH, Method::DELETE])
         .allow_credentials(true)
         .allow_headers([AUTHORIZATION, ACCEPT, CONTENT_TYPE]);
 
+    // Build router with all endpoints and apply CORS middleware
     let app = create_router(Arc::new(AppState {
         db: pool.clone(),
         env: env.clone(),
     }))
     .layer(cors);
 
+    // Start listening for incoming connections
     let listener = tokio::net::TcpListener::bind("0.0.0.0:8001").await.unwrap();
-    axum::serve(listener, app).await;
+    let _ = axum::serve(listener, app).await;
 }

backend/src/models.rs

@@ -1,20 +1,35 @@
-use std::fmt::Display;
-
 use serde::{Deserialize, Serialize};
-use sqlx::{Decode, prelude::Type};
-
-#[derive(Deserialize, Serialize, PartialEq, Debug, sqlx::FromRow)]
-pub struct Ticket {
-    pub id: i32,
-    pub category: String,
-    pub betreff: String,
-    pub description: String,
-    pub room: i16,
-    pub status: String,
-    pub date: chrono::NaiveDateTime,
-    pub user_id: i16,
-}
 
+/// API response for a ticket with user information.
+///
+/// Returned by ticket endpoints. Includes denormalized user data for easier frontend rendering.
+///
+/// # Fields
+/// - `id`: Unique ticket identifier
+/// - `category`: Ticket category/type
+/// - `betreff`: Ticket subject line
+/// - `description`: Detailed ticket description
+/// - `room`: Room number associated with the issue
+/// - `status`: Current ticket status (e.g., "open", "in_progress", "resolved")
+/// - `date`: When the ticket was created (UTC timestamp)
+/// - `user_id`: ID of the user who created the ticket
+/// - `user_first_name`, `user_last_name`: User's name (denormalized for convenience)
+///
+/// # Example
+/// ```json
+/// {
+///   "id": 1,
+///   "category": "maintenance",
+///   "betreff": "Broken light in room 101",
+///   "description": "The ceiling light is not working",
+///   "room": 101,
+///   "status": "open",
+///   "date": "2024-01-15T10:30:00Z",
+///   "user_id": 5,
+///   "user_first_name": "John",
+///   "user_last_name": "Doe"
+/// }
+/// ```
 #[derive(Deserialize, Serialize, Debug, PartialEq)]
 pub struct TicketResponse {
     pub id: i32,
@@ -23,10 +38,27 @@ pub struct TicketResponse {
     pub description: String,
     pub room: i16,
     pub status: String,
-    pub date: chrono::NaiveDateTime,
+    pub date: chrono::DateTime<chrono::Utc>,
     pub user_id: i16,
+    pub user_first_name: String,
+    pub user_last_name: String,
 }
 
+/// Complete user record from the database.
+///
+/// Contains all user information including the password hash.
+/// This should NEVER be sent directly to clients - always use `FilteredUser` instead.
+///
+/// # Fields
+/// - `id`: Unique user identifier
+/// - `first_name`, `last_name`: User's full name
+/// - `username`: Login username (must be unique)
+/// - `is_admin`: Whether user has admin privileges
+/// - `pwd`: Argon2 password hash (NEVER expose to clients)
+///
+/// # Security Note
+/// The `pwd` field contains the password hash and should never be included in API responses.
+/// Use `filter_user()` to convert to `FilteredUser` for responses.
 #[derive(Deserialize, Serialize, PartialEq, Debug, Clone, sqlx::FromRow)]
 pub struct User {
     pub id: i16,
@@ -37,6 +69,16 @@ pub struct User {
     pub pwd: String,
 }
 
+/// Payload for creating a new ticket.
+///
+/// Sent to `/api/tickets/create`. The backend automatically associates it with the
+/// authenticated user and sets the creation timestamp.
+///
+/// # Fields
+/// - `category`: Ticket category/type
+/// - `betreff`: Subject line for the ticket
+/// - `description`: Detailed problem description
+/// - `room`: Room number where the issue is located
 #[derive(Deserialize, Serialize, Debug)]
 pub struct TicketCreateScheme {
     pub category: String,
@@ -45,11 +87,29 @@ pub struct TicketCreateScheme {
     pub room: i16,
 }
 
+/// Payload for updating a ticket.
+///
+/// Sent to `PATCH /api/tickets/{id}`. Currently only allows status updates.
+/// Only admins can update tickets.
+///
+/// # Fields
+/// - `status`: New ticket status (e.g., "open", "in_progress", "resolved")
 #[derive(Deserialize, Serialize, Debug)]
 pub struct TicketUpdateScheme {
     pub status: String,
 }
 
+/// Payload for updating user information.
+///
+/// Sent to `PATCH /api/users/{id}`. Allows updating profile and admin status.
+/// Only admins can update users. Empty password field means no password change.
+///
+/// # Fields
+/// - `id`: User ID to update
+/// - `first_name`, `last_name`: Updated user name
+/// - `username`: Updated login username
+/// - `make_admin`: New admin privilege status
+/// - `new_pwd`: New password (empty string = keep existing password)
 #[derive(Deserialize, Serialize, Debug)]
 pub struct UserUpdateScheme {
     pub id: i16,
@@ -60,6 +120,17 @@ pub struct UserUpdateScheme {
     pub new_pwd: String,
 }
 
+/// Payload for creating a new user account.
+///
+/// Used in both admin registration (`/api/register`) and initial setup (`/api/setup-admin`).
+/// The password is hashed server-side before storage using Argon2.
+///
+/// # Fields
+/// - `first_name`: User's first name
+/// - `last_name`: User's last name
+/// - `username`: Unique username for login
+/// - `is_admin`: Whether to grant admin privileges (setup endpoint always sets this to true)
+/// - `pwd`: Plain text password (hashed on server)
 #[derive(Deserialize, Serialize, Debug, sqlx::FromRow)]
 pub struct UserCreateScheme {
     pub first_name: String,
@@ -69,13 +140,25 @@ pub struct UserCreateScheme {
     pub pwd: String,
 }
 
+/// Payload for user login.
+///
+/// Sent to `/api/login` endpoint with credentials. The backend verifies the password
+/// against the stored Argon2 hash.
+///
+/// # Security
+/// The password is never stored in plain text - only the Argon2 hash is persisted.
 #[derive(Deserialize, Serialize, Debug)]
 pub struct LoginScheme {
     pub username: String,
     pub pwd: String,
 }
 
-#[derive(Debug, Serialize)]
+/// User information sent to clients, excluding password hashes.
+///
+/// This is the safe version of User data that gets returned in API responses.
+/// It never includes the password hash or JWT claims. Always use this for responses
+/// to prevent leaking sensitive data.
+#[derive(Debug, Clone, Serialize)]
 pub struct FilteredUser {
     pub id: i16,
     pub first_name: String,
@@ -84,9 +167,27 @@ pub struct FilteredUser {
     pub is_admin: bool,
 }
 
+/// JWT token claims embedded in the session token.
+///
+/// Contains user identification and token validity information.
+/// Generated during login and verified by middleware on protected routes.
+///
+/// # Fields
+/// - `sub`: Subject - the user ID as a string
+/// - `issued`: Unix timestamp when token was created
+/// - `expires`: Unix timestamp when token expires (currently 1 hour from creation)
+///
+/// # Token Lifetime
+/// Tokens are valid for 1 hour. After expiration, user must log in again.
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Claims {
-    pub subject: String,
+    /// Subject - typically the user ID
+    #[serde(alias = "subject")]
+    pub sub: String,
+    /// Issued at time (Unix timestamp)
+    #[serde(rename = "iat", alias = "issued", default)]
     pub issued: usize,
+    /// Expiration time (Unix timestamp)
+    #[serde(rename = "exp", alias = "expires", default)]
     pub expires: usize,
 }

backend/src/router.rs

@@ -1,25 +1,57 @@
 use std::sync::Arc;
 
 use axum::{
-    Router,
+    Router, middleware,
     routing::{get, post},
 };
 
 use crate::{
     AppState,
+    cookie::validation::{validate_admin, validate_token},
+    get_count,
     handlers::{
         auth::{
-            create_user, delete_user, get_current_user, get_user_by_id, get_users, login, logout,
-            update_user,
+            check_admin_exists, create_user, delete_user, get_current_user, get_user_by_id,
+            get_users, login, logout, setup_initial_admin, update_user,
         },
         ticket::{create_ticket, delete_ticket, edit_ticket, get_ticket_by_id, get_tickets},
     },
+    increment,
 };
 
+/// Creates the complete router with all API endpoints.
+///
+/// The router is organized in layers for proper middleware application:
+///
+/// ## Route Layers (from most to least restricted):
+///
+/// ### Admin-Only Routes (requires admin privilege + valid token)
+/// - `GET /api/tickets/{id}` - Get specific ticket details
+/// - `DELETE /api/tickets/{id}` - Delete a ticket
+/// - `PATCH /api/tickets/{id}` - Update ticket status
+/// - `POST /api/register` - Create a new user
+/// - `GET /api/users` - List all users
+/// - `GET /api/users/{id}` - Get user details
+/// - `DELETE /api/users/{id}` - Delete a user
+/// - `PATCH /api/users/{id}` - Update user details
+///
+/// ### Protected Routes (requires valid token)
+/// - `GET /api/tickets` - List all tickets
+/// - `POST /api/tickets/create` - Create a new ticket
+/// - `GET /api/logout` - Logout user
+/// - `GET /api/users/current` - Get current authenticated user
+///
+/// ### Public Routes (no authentication required)
+/// - `POST /api/login` - User login
+/// - `GET /api/check-admin` - Check if admin exists (for setup detection)
+/// - `POST /api/setup-admin` - Create initial admin account (only if no admin exists)
+///
+/// # Middleware Stack
+/// - Admin routes have `validate_admin` middleware
+/// - Protected routes have `validate_token` middleware
+/// - Public routes have no authentication requirements
 pub fn create_router(state: Arc<AppState>) -> Router {
-    Router::new()
-        .route("/api/tickets", get(get_tickets))
-        .route("/api/tickets/create", post(create_ticket))
+    let admin_routes = Router::new()
         .route(
             "/api/tickets/{id}",
             get(get_ticket_by_id)
@@ -27,13 +59,32 @@ pub fn create_router(state: Arc<AppState>) -> Router {
                 .patch(edit_ticket),
         )
         .route("/api/register", post(create_user))
-        .route("/api/login", post(login))
-        .route("/api/logout", get(logout))
         .route("/api/users", get(get_users))
-        .route("/api/users/current", get(get_current_user))
         .route(
             "/api/users/{id}",
             get(get_user_by_id).delete(delete_user).patch(update_user),
         )
+        .layer(middleware::from_fn_with_state(
+            state.clone(),
+            validate_admin,
+        ));
+
+    let protected_routes = Router::new()
+        .merge(admin_routes)
+        .route("/api/tickets", get(get_tickets))
+        .route("/api/tickets/create", post(create_ticket))
+        .route("/api/logout", get(logout))
+        .route("/api/users/current", get(get_current_user))
+        .route("/api/count", get(get_count).post(increment))
+        .layer(middleware::from_fn_with_state(
+            state.clone(),
+            validate_token,
+        ));
+
+    Router::new()
+        .merge(protected_routes)
+        .route("/api/login", post(login))
+        .route("/api/check-admin", get(check_admin_exists))
+        .route("/api/setup-admin", post(setup_initial_admin))
         .with_state(state)
 }

data/compose.yaml

@@ -0,0 +1,14 @@
+services:
+  postgres:
+    image: postgres:latest
+    container_name: postgres_ticket
+    restart: unless-stopped
+    ports:
+      - 5432:5432
+    environment:
+      - POSTGRES_PASSWORD=tickets
+    volumes:
+      - pg_data:/var/lib/postregsql/pg_data
+
+volumes:
+  pg_data:

frontend/Cargo.toml

@@ -12,15 +12,17 @@ path = "src/main.rs"
 
 [dependencies]
 yew = { version = "0.23", features = ["csr"] }
-serde = { version = "1.0.228", features = ["derive"] }
-wasm-bindgen = "0.2.118"
-wasm-bindgen-futures = "0.4.68"
+serde = { workspace = true }
+wasm-bindgen-futures = "0.4.70"
 web-sys = { version = "0.3.95", features = [
-  "Window","Document","Request","Response","Headers", "HtmlSelectElement",
-  "SubmitEvent","InputEvent","HtmlInputElement","Event", "HtmlFormElement"
+  "Window","Document","Request","Response","Headers", "HtmlSelectElement", "RequestCredentials",
+  "SubmitEvent","InputEvent","HtmlInputElement","Event", "HtmlFormElement", "MouseEvent"
 ] }
 gloo-net = "0.7.0"
+gloo-storage = "0.4.0"
 yew-router = "0.20.0"
-serde_json = "1.0.149"
+serde_json = { workspace = true }
 gloo = "0.12.0"
-chrono = { version = "0.4.44", features = ["serde"] }
+chrono = { workspace = true }
+chrono-tz = "0.10.4"
+wasm-bindgen = "0.2.120"

frontend/Trunk.toml

@@ -1,6 +1,6 @@
 [serve]
 # The address to serve on LAN.
-addresses = ["127.0.0.1"]
+addresses = ["127.0.0.1"]#, "192.168.178.56"] #,"10.150.9.116"]
 # The address to serve on WAN.
 # address = "0.0.0.0"
 # The port to serve on.

frontend/index.html

@@ -1,10 +1,14 @@
 <!doctype html>
 <html>
+
 <head>
     <link data-trunk rel="rust" data-bin="bin" />
+    <link data-trunk rel="scss" href="src/styles/main.scss" />
+    <link data-trunk rel="icon" href="src/assets/favicon.ico" type="image/x-icon" />
     <meta charset="utf-8" />
-        <title>Yew App</title>
+    <title>Ticket System CSG</title>
 </head>
-    <body></body>
-</html>
 
+<body></body>
+
+</html>

frontend/src/auth.rs

@@ -0,0 +1,136 @@
+use gloo_net::http::Request;
+use wasm_bindgen_futures::spawn_local;
+use yew::prelude::*;
+use yew_router::prelude::*;
+
+/// Represents the authentication state of the current user.
+///
+/// This struct holds information about whether a user is authenticated and if they
+/// possess administrator privileges.
+///
+/// # Fields
+/// - `is_authenticated`: An `Option<bool>` indicating if the user is logged in.
+///   `None` means the status is still being checked.
+/// - `is_admin`: An `Option<bool>` indicating if the authenticated user is an administrator.
+///   `None` means the admin status is still being checked or is not applicable.
+#[derive(Clone, Debug, PartialEq)]
+pub struct AuthState {
+    pub is_authenticated: Option<bool>,
+    pub is_admin: Option<bool>,
+}
+
+/// Properties for the [`ProtectedRoute`] component.
+///
+/// # Fields
+/// - `children`: The child components that this protected route will render if access is granted.
+/// - `admin_page`: A boolean flag indicating whether this route requires administrator privileges.
+///   If `true`, the user must be authenticated AND be an administrator to access the `children`.
+#[derive(Properties, PartialEq)]
+pub struct ProtectedRouteProps {
+    pub children: Children,
+    pub admin_page: bool,
+}
+
+/// A component that protects routes by enforcing authentication and optional administrator privileges.
+///
+/// This component fetches the current user's authentication and admin status from the
+/// `/api/users/current` endpoint upon mounting. Based on the `AuthState` and the
+/// `admin_page` property, it either renders its children or redirects the user.
+///
+/// # Behavior
+/// - **Initial Load**: Displays "Loading..." while checking authentication status.
+/// - **Not Authenticated**: Redirects to the login page (`crate::Route::Login`).
+/// - **Authenticated**:
+///   - If `admin_page` is `true`:
+///     - If the user is an administrator (`is_admin: Some(true)`), it renders `children`.
+///     - If the user is not an administrator (`is_admin: Some(false)`), it redirects to
+///       the permission denied page (`crate::Route::PermissionDenied`).
+///     - If admin status is still being checked (`is_admin: None`), it displays "Checking permissions...".
+///   - If `admin_page` is `false`: It renders `children` directly, as only authentication is required.
+///
+/// # Example Usage
+/// ```ignore
+/// html! {
+///     <ProtectedRoute admin_page={true}>
+///         <AdminDashboard />
+///     </ProtectedRoute>
+/// }
+/// ```
+#[component(ProtectedRoute)]
+pub fn protected_route(props: &ProtectedRouteProps) -> Html {
+    let auth_state = use_state(|| AuthState {
+        is_authenticated: None,
+        is_admin: None,
+    });
+
+    {
+        let auth_state = auth_state.clone();
+        use_effect_with((), move |_| {
+            let auth_state = auth_state.clone();
+            spawn_local(async move {
+                match Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await
+                {
+                    Ok(resp) => {
+                        let status = resp.status();
+                        web_sys::console::log_1(&format!("Auth check: status {}", status).into());
+                        if status == 200 {
+                            let user_data: serde_json::Value =
+                                resp.json().await.unwrap_or_default();
+                            let is_admin = user_data["data"]["is_admin"].as_bool();
+
+                            auth_state.set(AuthState {
+                                is_authenticated: Some(true),
+                                is_admin,
+                            });
+                        } else {
+                            auth_state.set(AuthState {
+                                is_authenticated: Some(false),
+                                is_admin: Some(false),
+                            });
+                        }
+                    }
+                    Err(err) => {
+                        web_sys::console::log_1(&format!("Auth check error: {:?}", err).into());
+                        auth_state.set(AuthState {
+                            is_authenticated: Some(false),
+                            is_admin: Some(false),
+                        });
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
+    match *auth_state {
+        AuthState {
+            is_authenticated: None,
+            ..
+        } => html! { <div>{ "Loading..." } </div> },
+        AuthState {
+            is_authenticated: Some(false),
+            ..
+        } => html! {
+            <Redirect<crate::Route> to={crate::Route::Login}/>
+        },
+        AuthState {
+            is_authenticated: Some(true),
+            is_admin: admin_flag,
+        } => {
+            if props.admin_page {
+                match admin_flag {
+                    Some(true) => props.children.clone().into(),
+                    Some(false) => {
+                        html! { <Redirect<crate::Route> to={crate::Route::PermissionDenied}/> }
+                    }
+                    None => html! { <div>{ "Checking permissions..." }</div> },
+                }
+            } else {
+                props.children.clone().into()
+            }
+        }
+    }
+}

frontend/src/lib.rs

@@ -1,36 +1,270 @@
+mod auth;
 mod pages;
+use crate::auth::ProtectedRoute;
 use crate::pages::*;
+use gloo_net::http::Request;
+use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
 use yew_router::prelude::*;
 
+/// Defines the application's various routes and their corresponding paths.
+///
+/// This enum is used by `yew-router` to map URLs to specific components,
+/// enabling navigation within the single-page application.
 #[derive(Clone, PartialEq, Routable)]
 enum Route {
+    /// The application's home page.
     #[at("/")]
     Home,
+    /// Route for submitting a new ticket.
     #[at("/ticket")]
     Ticket,
+    /// Route for viewing a specific ticket by its ID.
     #[at("/tickets/:id")]
     TicketById { id: i32 },
+    /// Route for viewing all tickets.
     #[at("/tickets")]
     AllTickets,
+    /// Route for viewing archived tickets.
+    #[at("/tickets/archive")]
+    ArchivedTickets,
+    /// Route for user registration.
     #[at("/register")]
     Register,
+    /// Route for user login.
+    #[at("/login")]
+    Login,
+    /// Route for the initial administrator setup.
+    #[at("/setup")]
+    Setup,
+    /// Route for viewing all users.
+    #[at("/users")]
+    AllUsers,
+    /// Route for viewing a specific user by their ID.
+    #[at("/users/:id")]
+    UserByID { id: i16 },
+    /// Route for displaying diagnostics information (admin-only).
+    #[at("/diagnostics")]
+    Diagnostics,
+    /// Route displayed when a user attempts to access a page without sufficient permissions.
+    #[at("/denied")]
+    PermissionDenied,
+    /// Catch-all route for unmatched paths, leading to a 404 Not Found page.
     #[not_found]
     #[at("/404")]
     NotFound,
 }
 
-fn switch(route: Route) -> Html {
-    match route {
-        Route::Home => html! { <basic_pages::Home/>},
-        Route::NotFound => html! { <basic_pages::NotFound/> },
-        Route::Ticket => html! { <ticket::SubmitTicket/> },
-        Route::TicketById { id } => html! { <ticket::ShowTicketByID id={id}/> },
-        Route::AllTickets => html! { <ticket::AllTickets/> },
-        Route::Register => html! { <user::Register/> },
+/// Properties for the [`SidebarShell`] component.
+#[derive(Properties, PartialEq)]
+pub struct SidebarShellProps {
+    /// The child components to be rendered within the main content area of the shell.
+    pub children: Children,
+}
+
+/// A shell component that provides a consistent layout with a sidebar and a main content area.
+///
+/// This component is designed to wrap page-specific content, ensuring that the sidebar
+/// is always present for navigation.
+///
+/// # Components
+/// - [`sidebar::Sidebar`]: The navigation sidebar component.
+/// - Main content area: Renders the `children` passed to this component.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <SidebarShell>
+///         <p>{"Your page content goes here."}</p>
+///     </SidebarShell>
+/// }
+/// ```
+#[component(SidebarShell)]
+fn sidebar_shell(props: &SidebarShellProps) -> Html {
+    html! {
+        <div class="layout">
+            <sidebar::Sidebar/>
+            <main class="content">
+                { for props.children.iter() }
+            </main>
+        </div>
     }
 }
 
+/// Props for the [AdminCheckWrapper] component.
+#[derive(Properties, PartialEq)]
+pub struct AdminCheckWrapperProps {
+    pub children: Children,
+}
+
+/// Wrapper component that checks if an admin exists before rendering children.
+///
+/// This component is used to gate access to pages that should only be accessible before
+/// system initialization (e.g., login page). It performs an asynchronous check to the
+/// `/api/check-admin` endpoint to determine system state.
+///
+/// # Behavior
+/// - **Loading**: Displays "Loading..." while checking admin status
+/// - **No Admin**: Automatically redirects to `/setup` page to initialize
+/// - **Admin Exists**: Renders the wrapped children (e.g., login page)
+///
+/// # Example Usage
+/// ```ignore
+/// <AdminCheckWrapper>
+///     <LoginPage />
+/// </AdminCheckWrapper>
+/// ```
+///
+/// # Implementation Detail
+/// The check happens in `use_effect_with` on component mount:
+/// ```ignore
+/// spawn_local(async move {
+///     match Request::get("/api/check-admin").send().await {
+///         Ok(resp) if resp.status() == 200 => {
+///             let has_admin = data["has_admin"].as_bool().unwrap_or(false);
+///             admin_exists.set(Some(has_admin));
+///         }
+///         _ => admin_exists.set(Some(false))
+///     }
+/// });
+/// ```
+#[component(AdminCheckWrapper)]
+fn admin_check_wrapper(props: &AdminCheckWrapperProps) -> Html {
+    let admin_exists = use_state(|| None::<bool>);
+    let navigator = use_navigator().unwrap();
+
+    {
+        let admin_exists = admin_exists.clone();
+        use_effect_with((), move |_| {
+            let admin_exists = admin_exists.clone();
+            spawn_local(async move {
+                match Request::get("/api/check-admin").send().await {
+                    Ok(resp) if resp.status() == 200 => {
+                        if let Ok(data) = resp.json::<serde_json::Value>().await {
+                            let has_admin = data["has_admin"].as_bool().unwrap_or(false);
+                            admin_exists.set(Some(has_admin));
+                        }
+                    }
+                    _ => {
+                        admin_exists.set(Some(false));
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
+    match *admin_exists {
+        None => html! { <div>{ "Loading..." }</div> },
+        Some(false) => {
+            navigator.push(&Route::Setup);
+            html! { <div>{ "Redirecting to setup..." }</div> }
+        }
+        Some(true) => props.children.clone().into(),
+    }
+}
+
+/// The main routing logic for the application.
+///
+/// This function takes a [Route] enum variant and returns the corresponding HTML
+/// content to be rendered. It acts as a central dispatcher for the application's
+/// navigation.
+///
+/// Many routes are wrapped in a [`ProtectedRoute`] to enforce authentication
+/// and authorization, and in a [`SidebarShell`] to maintain consistent layout.
+///
+/// # Arguments
+/// - `route`: The [`Route`] enum variant representing the current URL path.
+///
+/// # Returns
+/// An `Html` component that should be rendered for the given route.
+fn switch(route: Route) -> Html {
+    match route {
+        Route::Home => html! {
+            <ProtectedRoute admin_page={false}>
+                <SidebarShell>
+                    <basic_pages::Home/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::NotFound => html! { <basic_pages::NotFound/> },
+        Route::Ticket => html! {
+            <ProtectedRoute admin_page={false}>
+                <SidebarShell>
+                    <ticket::SubmitTicket/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::TicketById { id } => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <ticket::TicketByID {id}/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::AllTickets => html! {
+            <ProtectedRoute admin_page={false}>
+                <SidebarShell>
+                    <ticket::AllTickets/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::ArchivedTickets => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <ticket::ArchivedTickets/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::Register => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <user::Register/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::Login => html! {
+            <AdminCheckWrapper>
+                <user::Login/>
+            </AdminCheckWrapper>
+        },
+        Route::Setup => html! {
+            <setup::InitialAdminSetup/>
+        },
+        Route::AllUsers => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <user::AllUsers/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::UserByID { id } => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <user::UserByID {id}/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+        Route::PermissionDenied => html! { <basic_pages::PermissionDenied/> },
+        Route::Diagnostics => html! {
+            <ProtectedRoute admin_page={true}>
+                <SidebarShell>
+                    <utilities::Diagnostics/>
+                </SidebarShell>
+            </ProtectedRoute>
+        },
+    }
+}
+
+/// The root component of the Yew application.
+///
+/// This component sets up the application's routing using `yew-router`'s
+/// `BrowserRouter` and `Switch` components. All other application content
+/// is rendered based on the current route.
+///
+/// # Structure
+/// - `BrowserRouter`: Enables client-side routing.
+/// - `Switch`: Renders components based on the matched [Route].
 #[component(App)]
 pub fn app() -> Html {
     html! {

frontend/src/pages/basic_pages.rs

@@ -1,30 +1,119 @@
+use gloo_net::http::Request;
+use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
+use yew_router::prelude::*;
 
+/// A macro for dequoting a Json value returned from the backend
+#[macro_export]
+macro_rules! dequote {
+    ($str:expr) => {
+        $str.trim_matches('"').to_string()
+    };
+}
+
+/// The main home page component of the application.
+///
+/// This component displays different content based on whether the logged-in user
+/// is an administrator. It fetches the user's admin status from the
+/// `/api/users/current` endpoint upon initialization.
+///
+/// # Behavior
+/// - **Loading**: Displays "Loading..." while fetching user data.
+/// - **Admin User**: Renders the `TicketCount` utility component.
+/// - **Non-Admin User**: Renders the `TicketCount` utility component.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <Home />
+/// }
+/// ```
 #[component(Home)]
 pub fn home_component() -> Html {
-    let counter = use_state(|| 0);
-    let onclick = {
-        let counter = counter.clone();
-        move |_| {
-            let value = *counter + 1;
-            counter.set(value);
+    let name = use_state(|| "".to_string());
+    {
+        let name = name.clone();
+        use_effect_with((), move |_| {
+            spawn_local(async move {
+                let response = Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) if resp.status() == 200 => {
+                        let user_data: serde_json::Value = resp.json().await.unwrap_or_default();
+                        let name_value = format!(
+                            "{} {}",
+                            dequote!(user_data["data"]["first_name"].to_string()),
+                            dequote!(user_data["data"]["last_name"].to_string())
+                        );
+                        name.set(name_value);
+                    }
+                    _ => name.set("Unknown".to_string()),
+                }
+            });
+            || ()
+        });
     }
-    };
 
     html! {
+        <div class="form-container home">
+            <div class="page-header">
+                <h1>{ "Welcome" }</h1>
+            </div>
+            <crate::utilities::TicketCount/>
             <div>
-            <button {onclick}>{ "+1" }</button>
-            <p>{ *counter }</p>
+                <p>{ "You are logged in as: " }</p>
+                <p class="text-muted">{ &*name }</p>
+            </div>
         </div>
     }
 }
 
+/// A basic component displayed when a requested route does not match any defined paths (404 error).
+///
+/// It provides a simple message indicating that the page was not found and includes
+/// a link to navigate back to the home page.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <NotFound />
+/// }
+/// ```
 #[component(NotFound)]
 pub fn not_found_component() -> Html {
     let message = "404 Not found";
     html! {
-        <div>
+        <div class="form-container">
+            <div class="empty-state">
                 <h1>{&message}</h1>
+                <p>{ "The page you are looking for does not exist." }</p>
+                <Link<crate::Route> to={crate::Route::Home}>{ "Back to Home" }</Link<crate::Route>>
+            </div>
+        </div>
+    }
+}
+
+/// A component displayed when a user attempts to access a page for which they do not have sufficient permissions.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <PermissionDenied />
+/// }
+/// ```
+#[component(PermissionDenied)]
+pub fn denied_component() -> Html {
+    html! {
+        <div class="form-container">
+            <div class="empty-state">
+                <h1>{ "Access Denied" }</h1>
+                <p>{ "Sie haben nicht die benötigten Rechte um diese Seite aufzurufen" }</p>
+                <p class="text-muted">{ "Wenn sie denken, dass dies ein Fehler ist kontaktieren sie Herrn Winter" }</p>
+                <Link<crate::Route> to={crate::Route::Home}>{ "Back to Home" }</Link<crate::Route>>
+            </div>
         </div>
     }
 }

frontend/src/pages/mod.rs

@@ -1,3 +1,13 @@
+//! This module aggregates and re-exports all individual page components of the application.
+//!
+//! Each sub-module within `pages` typically represents a distinct view or section
+//! of the user interface, such as authentication, ticket management, or user profiles.
+//!
+//! By re-exporting them here, other parts of the application can import page
+//! components more conveniently using `crate::pages::*`.
 pub mod basic_pages;
+pub mod setup;
+pub mod sidebar;
 pub mod ticket;
 pub mod user;
+pub mod utilities;

frontend/src/pages/setup.rs

@@ -0,0 +1,281 @@
+use gloo_net::http::Request;
+use serde::{Deserialize, Serialize};
+use wasm_bindgen_futures::spawn_local;
+use yew::prelude::*;
+use yew_router::prelude::*;
+
+/// Payload for creating the initial administrator account.
+///
+/// This struct is sent to the `/api/setup-admin` endpoint to create the first admin user
+/// when no administrators exist in the system. It carries the necessary information
+/// for the new admin's profile and credentials.
+///
+/// # Fields
+/// - `first_name`: The first name of the administrator.
+/// - `last_name`: The last name of the administrator.
+/// - `username`: The unique username for the administrator's login.
+/// - `pwd`: The password for the administrator's account. This will be hashed on the backend.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct AdminSetupScheme {
+    pub first_name: String,
+    pub last_name: String,
+    pub username: String,
+    pub pwd: String,
+}
+
+/// Component for the initial admin account setup page.
+///
+/// This page is displayed when a fresh system has no administrator accounts. It provides
+/// a form to create the first admin user. Key functionality:
+///
+/// - **Admin Check**: On mount, verifies if an admin already exists by calling `/api/check-admin`.
+///   If an admin is found, the user is redirected to the login page (`crate::Route::Login`).
+/// - **Form Fields**: Collects `first_name`, `last_name`, `username`, `password`, and `confirm_password`.
+/// - **Form Validation**:
+///   - Ensures password fields are not empty.
+///   - Verifies that `password` and `confirm_password` match.
+///   - Ensures the `username` field is not empty.
+/// - **API Interaction**: On form submission, a POST request is sent to `/api/setup-admin`
+///   with the new admin's details.
+/// - **Password Hashing**: The backend is responsible for hashing the password using Argon2
+///   before storage; this component only sends the plain text password.
+/// - **Auto-redirect**: On successful admin account creation, the user is automatically
+///   redirected to the login page (`crate::Route::Login`).
+/// - **State Management**: Uses Yew's `use_state` hooks to manage:
+///   - Input field values (`first_name`, `last_name`, `username`, `pwd`, `pwd_confirm`).
+///   - UI states like `error` messages, `success` status, and `loading` indicators.
+///   - `admin_check_done` to prevent rendering the form before the initial admin check completes.
+///
+/// # Example Flow
+/// 1. User navigates to `/setup`.
+/// 2. The component checks `/api/check-admin`.
+/// 3. If an admin exists, redirects to `/login`.
+/// 4. If no admin exists, the setup form is displayed.
+/// 5. User fills out the form and submits.
+/// 6. Form data is sent via POST to `/api/setup-admin`.
+/// 7. On successful response (HTTP 200), redirects to `/login`.
+/// 8. On error, displays an error message to the user.
+///
+/// # Security Notes
+/// - The initial admin check prevents re-creating an admin if one already exists.
+/// - Password confirmation helps prevent user typos for critical credentials.
+/// - Backend validation further ensures non-empty and secure credentials.
+#[component(InitialAdminSetup)]
+pub fn initial_admin_setup() -> Html {
+    let first_name = use_state(|| "".to_string());
+    let last_name = use_state(|| "".to_string());
+    let username = use_state(|| "".to_string());
+    let pwd = use_state(|| "".to_string());
+    let pwd_confirm = use_state(|| "".to_string());
+    let error = use_state(|| String::new());
+    let success = use_state(|| false);
+    let loading = use_state(|| false);
+    let admin_check_done = use_state(|| false);
+    let navigator = use_navigator().unwrap();
+
+    {
+        let admin_check_done = admin_check_done.clone();
+        let navigator = navigator.clone();
+        use_effect_with((), move |_| {
+            let admin_check_done = admin_check_done.clone();
+            let navigator = navigator.clone();
+            spawn_local(async move {
+                match Request::get("/api/check-admin").send().await {
+                    Ok(resp) if resp.status() == 200 => {
+                        if let Ok(data) = resp.json::<serde_json::Value>().await {
+                            let has_admin = data["has_admin"].as_bool().unwrap_or(false);
+                            if has_admin {
+                                navigator.push(&crate::Route::Login);
+                            } else {
+                                admin_check_done.set(true);
+                            }
+                        } else {
+                            admin_check_done.set(true);
+                        }
+                    }
+                    _ => {
+                        admin_check_done.set(true);
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
+    if !*admin_check_done {
+        return html! { <div>{ "Checking..." }</div> };
+    }
+
+    let onsubmit = {
+        let first_name = first_name.clone();
+        let last_name = last_name.clone();
+        let username = username.clone();
+        let pwd = pwd.clone();
+        let pwd_confirm = pwd_confirm.clone();
+        let error = error.clone();
+        let success = success.clone();
+        let loading = loading.clone();
+        let navigator = navigator.clone();
+
+        Callback::from(move |e: SubmitEvent| {
+            e.prevent_default();
+
+            if (*pwd).is_empty() || (*pwd_confirm).is_empty() {
+                error.set("Password fields cannot be empty".to_string());
+                return;
+            }
+
+            if *pwd != *pwd_confirm {
+                error.set("Passwords do not match".to_string());
+                return;
+            }
+
+            if (*username).is_empty() {
+                error.set("Username cannot be empty".to_string());
+                return;
+            }
+
+            let first_name_val = (*first_name).clone();
+            let last_name_val = (*last_name).clone();
+            let username_val = (*username).clone();
+            let pwd_val = (*pwd).clone();
+
+            loading.set(true);
+            error.set(String::new());
+            success.set(false);
+
+            let error = error.clone();
+            let success = success.clone();
+            let loading = loading.clone();
+            let navigator = navigator.clone();
+
+            spawn_local(async move {
+                let payload = AdminSetupScheme {
+                    first_name: first_name_val,
+                    last_name: last_name_val,
+                    username: username_val,
+                    pwd: pwd_val,
+                };
+
+                let response = Request::post("/api/setup-admin")
+                    .header("Content-Type", "application/json")
+                    .json(&payload)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                loading.set(false);
+
+                match response {
+                    Ok(r) if r.status() == 200 => {
+                        success.set(true);
+                        navigator.push(&crate::Route::Login);
+                    }
+                    Ok(r) => {
+                        let text = r.text().await.unwrap_or_else(|_| "unknown".into());
+                        error.set(format!("HTTP {}: {}", r.status(), text));
+                    }
+                    Err(err) => error.set(format!("Network error: {}", err)),
+                }
+            });
+        })
+    };
+
+    html! {
+        <div class="setup-container">
+            <div class="setup-box">
+                <h1>{ "Initial Admin Setup" }</h1>
+                <p>{ "Create your first administrator account" }</p>
+
+                <form {onsubmit} class="setup-form">
+                    <div class="form-group">
+                        <label for="first_name">{ "First Name:" }
+                            <input
+                                id="first_name"
+                                type="text"
+                                placeholder="First name"
+                                value={(*first_name).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    first_name.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="last_name">{ "Last Name:" }
+                            <input
+                                id="last_name"
+                                type="text"
+                                placeholder="Last name"
+                                value={(*last_name).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    last_name.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="username">{ "Username:" }
+                            <input
+                                id="username"
+                                type="text"
+                                placeholder="Username"
+                                value={(*username).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    username.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="password">{ "Password:" }
+                            <input
+                                id="password"
+                                type="password"
+                                placeholder="Password"
+                                value={(*pwd).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    pwd.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <div class="form-group">
+                        <label for="pwd_confirm">{ "Confirm Password:" }
+                            <input
+                                id="pwd_confirm"
+                                type="password"
+                                placeholder="Confirm password"
+                                value={(*pwd_confirm).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    pwd_confirm.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <button type="submit" disabled={*loading} class="submit-btn">
+                        { if *loading { "Creating..." } else { "Create Admin Account" } }
+                    </button>
+
+                    if !error.is_empty() {
+                        <p class="error-message" style="color:red">{ (*error).clone() }</p>
+                    }
+
+                    if *success {
+                        <p class="success-message" style="color:green">{ "Admin account created successfully! Redirecting to login..." }</p>
+                    }
+                </form>
+            </div>
+        </div>
+    }
+}

frontend/src/pages/sidebar.rs

@@ -0,0 +1,422 @@
+use gloo_net::http::Request;
+use gloo_storage::{LocalStorage, Storage};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::rc::Rc;
+use wasm_bindgen_futures::spawn_local;
+use yew::prelude::*;
+use yew_router::prelude::*;
+
+const STORAGE_KEY: &str = "sidebar_state";
+
+/// Represents the expansion state of collapsible menus within the sidebar.
+///
+/// This struct is used to persist the open/closed state of sidebar submenus,
+/// improving user experience by remembering their last interaction.
+/// The state is stored in and retrieved from `LocalStorage`.
+///
+/// # Fields
+/// - `ticket_open`: A boolean indicating if the "Tickets" submenu is expanded (`true`) or collapsed (`false`).
+/// - `users_open`: A boolean indicating if the "Users" submenu is expanded (`true`) or collapsed (`false`).
+#[derive(Clone, PartialEq, Serialize, Deserialize)]
+pub struct SidebarExpandState {
+    pub ticket_open: bool,
+    pub users_open: bool,
+}
+
+impl Default for SidebarExpandState {
+    /// Provides the default expansion state, where all submenus are collapsed.
+    fn default() -> Self {
+        Self {
+            ticket_open: false,
+            users_open: false,
+        }
+    }
+}
+
+/// Represents the shared state for the sidebar's expandable menus.
+///
+/// This context struct is provided via Yew's `ContextProvider` and allows child components
+/// within the sidebar to read and modify the expansion state of the "Tickets" and "Users" menus.
+///
+/// # Fields
+/// - `expand`: The current [`SidebarExpandState`] holding whether each menu is open or closed.
+/// - `set_tickets_open`: A `Callback<bool>` to explicitly set the open state of the "Tickets" menu.
+/// - `toggle_tickets`: A `Callback<()>` to toggle the open state of the "Tickets" menu.
+/// - `set_users_open`: A `Callback<bool>` to explicitly set the open state of the "Users" menu.
+/// - `toggle_users`: A `Callback<()>` to toggle the open state of the "Users" menu.
+#[derive(Clone, PartialEq)]
+pub struct SidebarState {
+    pub expand: SidebarExpandState,
+    pub set_tickets_open: Callback<bool>,
+    pub toggle_tickets: Callback<()>,
+    pub set_users_open: Callback<bool>,
+    pub toggle_users: Callback<()>,
+}
+
+impl SidebarState {
+    /// Creates a new `SidebarState` instance.
+    ///
+    /// This constructor is typically used within the [`SidebarStateProvider`] to
+    /// bundle the current expansion state and its associated callbacks for context sharing.
+    fn new(
+        expand: SidebarExpandState,
+        set_tickets_open: Callback<bool>,
+        toggle_tickets: Callback<()>,
+        set_users_open: Callback<bool>,
+        toggle_users: Callback<()>,
+    ) -> Self {
+        Self {
+            expand,
+            set_tickets_open,
+            toggle_tickets,
+            set_users_open,
+            toggle_users,
+        }
+    }
+}
+
+/// Properties for components that provide sidebar state.
+///
+/// This struct is typically used by context providers that wrap child components
+/// and supply them with shared sidebar-related state or functionality.
+///
+/// # Fields
+/// - `children`: The child components that will have access to the provided sidebar state.
+#[derive(Properties, PartialEq)]
+pub struct SidebarProps {
+    pub children: Children,
+}
+
+/// A Yew context provider component that manages and supplies the sidebar's expansion state.
+///
+/// This component is responsible for:
+/// 1. Loading the initial `SidebarExpandState` from browser `LocalStorage` (or using defaults).
+/// 2. Providing a `SidebarState` context (`Rc<SidebarState>`) to its children, which includes
+///    the current expansion state and callbacks to modify it.
+/// 3. Persisting any changes to the `SidebarExpandState` back to `LocalStorage`.
+///
+/// Child components (like [`TicketMenu`] and [`UsersMenu`]) can consume this context
+/// to react to and control the sidebar's collapsible sections.
+///
+/// # LocalStorage Key
+/// The state is stored under the key `STORAGE_KEY` ("sidebar_state").
+///
+/// # Example Usage
+/// ```rust
+/// html! {
+///     <SidebarStateProvider>
+///         <Sidebar /> // Sidebar and its sub-components will have access to the state
+///     </SidebarStateProvider>
+/// }
+/// ```
+#[component(SidebarStateProvider)]
+pub fn sidebar_state_provider(props: &SidebarProps) -> Html {
+    let default = LocalStorage::get(STORAGE_KEY).unwrap_or_else(|_| SidebarExpandState::default());
+    let state = use_state(|| default);
+
+    {
+        let state = state.clone();
+        use_effect_with(state, move |s| {
+            LocalStorage::set(STORAGE_KEY, &**s).ok();
+            || ()
+        });
+    }
+
+    let set_tickets_open = {
+        let state = state.clone();
+        Callback::from(move |v: bool| {
+            state.set(SidebarExpandState {
+                ticket_open: v,
+                users_open: (*state).users_open,
+            })
+        })
+    };
+
+    let toggle_tickets = {
+        let state = state.clone();
+        Callback::from(move |_| {
+            let current = (*state).ticket_open;
+            state.set(SidebarExpandState {
+                ticket_open: !current,
+                users_open: (*state).users_open,
+            });
+        })
+    };
+
+    let set_users_open = {
+        let state = state.clone();
+        Callback::from(move |v: bool| {
+            state.set(SidebarExpandState {
+                ticket_open: (*state).ticket_open,
+                users_open: v,
+            })
+        })
+    };
+
+    let toggle_users = {
+        let state = state.clone();
+        Callback::from(move |_| {
+            let current = (*state).users_open;
+            state.set(SidebarExpandState {
+                ticket_open: (*state).ticket_open,
+                users_open: !current,
+            });
+        })
+    };
+
+    let ctx = SidebarState::new(
+        (*state).clone(),
+        set_tickets_open,
+        toggle_tickets,
+        set_users_open,
+        toggle_users,
+    );
+
+    html! {
+        <ContextProvider<Rc<SidebarState>> context={Rc::new(ctx)}>
+            { for props.children.iter() }
+        </ContextProvider<Rc<SidebarState>>>
+    }
+}
+
+/// A collapsible menu component for "Tickets" within the sidebar.
+///
+/// This component consumes the [`SidebarState`] context to manage its expanded/collapsed state.
+/// It displays a button to toggle its visibility and, when expanded, reveals links
+/// for "Submit Ticket" and "View Tickets".
+///
+/// # Context
+/// Requires [`SidebarStateProvider`] as an ancestor to provide the necessary context.
+///
+/// # Functionality
+/// - **Toggle Button**: Clicking the button toggles the `ticket_open` state in the `SidebarState`.
+/// - **Submenu Links**:
+///   - [`crate::Route::Ticket`]: Link to submit a new ticket.
+///   - [`crate::Route::AllTickets`]: Link to view all tickets.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <TicketMenu />
+/// }
+/// ```
+#[component(TicketMenu)]
+pub fn ticket_menu() -> Html {
+    let ctx =
+        use_context::<Rc<SidebarState>>().expect("TicketsMenu must be inside SidebarStateProvider");
+
+    let on_toggle = {
+        let cb = ctx.toggle_tickets.clone();
+        Callback::from(move |_| cb.emit(()))
+    };
+
+    let open = ctx.expand.ticket_open;
+
+    html! {
+        <li class={ if open { "menu open" } else { "menu" } }>
+            <button
+                class="menu-toggle"
+                onclick={on_toggle}
+                aria-expanded={open.to_string()}
+            >
+                { "Tickets" }
+                { if open { " ▾" } else { " ▸" } }
+            </button>
+
+            {
+                if open {
+                    html! {
+                        <ul class="submenu" role="menu">
+                            <li role="none">
+                                <Link<crate::Route> to={crate::Route::Ticket}><span role="menuitem">{ "Submit Ticket" }</span></Link<crate::Route>>
+                            </li>
+                            <li role="none">
+                                <Link<crate::Route> to={crate::Route::AllTickets}><span role="menuitem">{ "View Tickets" }</span></Link<crate::Route>>
+                            </li>
+                        </ul>
+                    }
+                } else {
+                    html!{}
+                }
+            }
+        </li>
+    }
+}
+
+/// A collapsible menu component for "Users" within the sidebar.
+///
+/// This component consumes the [`SidebarState`] context to manage its expanded/collapsed state.
+/// It displays a button to toggle its visibility and, when expanded, reveals links
+/// for "Create User" and "View Users". This menu is typically only visible to administrators.
+///
+/// # Context
+/// Requires [`SidebarStateProvider`] as an ancestor to provide the necessary context.
+///
+/// # Functionality
+/// - **Toggle Button**: Clicking the button toggles the `users_open` state in the `SidebarState`.
+/// - **Submenu Links**:
+///   - [`crate::Route::Register`]: Link to create a new user account.
+///   - [`crate::Route::AllUsers`]: Link to view all registered users.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <UsersMenu />
+/// }
+/// ```
+#[component(UsersMenu)]
+pub fn users_menu() -> Html {
+    let ctx =
+        use_context::<Rc<SidebarState>>().expect("UsersMenu must be inside SidebarStateProvider");
+
+    let on_toggle = {
+        let cb = ctx.toggle_users.clone();
+        Callback::from(move |_| cb.emit(()))
+    };
+
+    let open = ctx.expand.users_open;
+
+    html! {
+        <li class={ if open { "menu open" } else { "menu" } }>
+            <button
+                class="menu-toggle"
+                onclick={on_toggle}
+                aria-expanded={open.to_string()}
+            >
+                { "Users" }
+                { if open { " ▾" } else { " ▸" } }
+            </button>
+
+            {
+                if open {
+                    html! {
+                        <ul class="submenu" role="menu">
+                            <li role="none">
+                                <Link<crate::Route> to={crate::Route::Register}><span role="menuitem">{ "Create User" }</span></Link<crate::Route>>
+                            </li>
+                            <li role="none">
+                                <Link<crate::Route> to={crate::Route::AllUsers}><span role="menuitem">{ "View Users" }</span></Link<crate::Route>>
+                            </li>
+                        </ul>
+                    }
+                } else {
+                    html!{}
+                }
+            }
+        </li>
+    }
+}
+
+/// The main sidebar component of the application.
+///
+/// This component dynamically renders its content based on the user's authentication
+/// and administrative status. It fetches the current user's details via `/api/users/current`
+/// to determine what menu items to display.
+///
+/// # Structure
+/// - Wraps its content in a [`SidebarStateProvider`] to allow nested menus to manage their state.
+/// - Contains a navigation (`<nav>`) element with an unordered list (`<ul>`) of menu items.
+///
+/// # Conditional Rendering
+/// - **Loading**: Displays "Loading..." while fetching user data.
+/// - **Non-Admin User**: Renders a condensed sidebar including:
+///   - [`TicketMenu`]: For managing tickets.
+///   - A "Logout" button.
+/// - **Admin User**: Renders a full sidebar including:
+///   - [`TicketMenu`]: For managing tickets.
+///   - [`UsersMenu`]: For managing user accounts.
+///   - A direct link to [`crate::Route::Diagnostics`] (Statistiken).
+///   - A "Logout" button.
+///
+/// # Logout Functionality
+/// The "Logout" button sends a GET request to `/api/logout`, clears the user's session,
+/// and then redirects the user to the login page (`crate::Route::Login`).
+#[component(Sidebar)]
+pub fn sidebar() -> Html {
+    let is_admin = use_state(|| None::<bool>);
+    let navigator = use_navigator().expect("Sidebar must be used within a Router");
+
+    {
+        let is_admin = is_admin.clone();
+        use_effect_with((), move |_| {
+            spawn_local(async move {
+                let response = Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await;
+
+                match response {
+                    Ok(resp) if resp.status() == 200 => {
+                        let user_data: Value = resp.json().await.unwrap_or_default();
+                        let admin_value = user_data["data"]["is_admin"].as_bool();
+                        is_admin.set(admin_value);
+                    }
+                    _ => is_admin.set(Some(false)),
+                }
+            });
+            || ()
+        });
+    }
+
+    let on_logout = {
+        let navigator = navigator.clone();
+        Callback::from(move |_| {
+            let navigator = navigator.clone();
+            spawn_local(async move {
+                let _ = Request::get("/api/logout")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await;
+                navigator.push(&crate::Route::Login);
+            });
+        })
+    };
+
+    match *is_admin {
+        None => html! { <div class="sidebar-loading">{ "Loading..." }</div> },
+
+        // Non-admin: render a condensed user sidebar (no diagnostics, limited links)
+        Some(false) => html! {
+            <SidebarStateProvider>
+                <nav class="sidebar user">
+                    <ul>
+                        <Link<crate::Route> to={crate::Route::Home}>{ "󰟒" }</Link<crate::Route>>
+                        <TicketMenu/>
+                        <li class="logout-item">
+                            <button
+                                class="logout-button"
+                                onclick={on_logout.clone()}
+                            >
+                                { "Logout" }
+                            </button>
+                        </li>
+                    </ul>
+                </nav>
+            </SidebarStateProvider>
+        },
+
+        // Admin: full sidebar wrapped in provider so submenu state persists
+        Some(true) => html! {
+            <SidebarStateProvider>
+                <nav class="sidebar admin">
+                    <ul>
+                        <Link<crate::Route> to={crate::Route::Home}>{ "󰟒" }</Link<crate::Route>>
+                        <TicketMenu/>
+                        <UsersMenu/>
+                        <Link<crate::Route> to={crate::Route::Diagnostics}>{ "Statistiken" }</Link<crate::Route>>
+                        <Link<crate::Route> to={crate::Route::ArchivedTickets}>{ "Archiv" }</Link<crate::Route>>
+                        <li class="logout-item">
+                            <button
+                                class="logout-button"
+                                onclick={on_logout.clone()}
+                            >
+                                { "Logout" }
+                            </button>
+                        </li>
+                    </ul>
+                </nav>
+            </SidebarStateProvider>
+        },
+    }
+}

frontend/src/pages/ticket.rs

@@ -1,10 +1,40 @@
+use std::collections::HashSet;
+
+use chrono_tz::Europe::Berlin;
 use gloo_net::http::Request;
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::spawn_local;
 use web_sys::HtmlSelectElement;
 use yew::prelude::*;
+use yew_router::prelude::*;
 
+/// A hardcoded list of valid room numbers for ticket submissions.
+///
+/// This array contains `i16` values representing valid rooms. Negative numbers typically
+/// denote rooms prefixed with 'K' (e.g., -1 for K1), and numbers greater than or equal to 1000
+/// denote rooms prefixed with 'D' (e.g., 1001 for D1).
+///
+/// This list is used for client-side validation of room input during ticket creation.
+const VALID_ROOMS: &[i16] = &[
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+    32, 34, 36, 37, 39, 41, 49, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
+    118, 120, 121, 122, 123, 124, 126, 127, 128, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+    143, 144, 145, 146, 147, 148, 150, 152, 153, 154, 155, 156, 157, 158, 159, 160, 201, 202, 203,
+    204, 205, 206, 207, 208, 209, 210, 211, 212, 214, 1001, 1002, 1003, -1, -2, -3, -4, -5, -6, -7,
+    -8,
+];
+
+/// Data transfer object (DTO) for creating a new ticket.
+///
+/// This struct defines the payload sent to the backend when a user submits a new ticket.
+/// It includes all necessary information for initial ticket creation.
+///
+/// # Fields
+/// - `category`: The category of the ticket (e.g., "Internet", "Hardware").
+/// - `betreff`: The subject or brief summary of the ticket.
+/// - `description`: A detailed description of the issue or request.
+/// - `room`: The room number where the issue is located.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct TicketCreateScheme {
     pub category: String,
@@ -13,11 +43,34 @@ pub struct TicketCreateScheme {
     pub room: i16,
 }
 
+/// Data transfer object (DTO) for updating a ticket's status.
+///
+/// This struct is used when sending a request to the backend to change the status
+/// of an existing ticket.
+///
+/// # Fields
+/// - `status`: The new status of the ticket (e.g., "ToDo", "InProgress", "Completed", "Archived").
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct TicketUpdateScheme {
     pub status: String,
 }
 
+/// Represents a complete ticket entity retrieved from the backend.
+///
+/// This struct holds all details of a ticket, including its metadata, content,
+/// and associated user information.
+///
+/// # Fields
+/// - `id`: The unique identifier of the ticket.
+/// - `category`: The category of the ticket.
+/// - `betreff`: The subject of the ticket.
+/// - `description`: The detailed description of the ticket.
+/// - `room`: The room number associated with the ticket.
+/// - `status`: The current status of the ticket.
+/// - `date`: The creation date and time of the ticket in UTC.
+/// - `user_id`: The ID of the user who created the ticket.
+/// - `user_first_name`: The first name of the user who created the ticket.
+/// - `user_last_name`: The last name of the user who created the ticket.
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 pub struct Ticket {
     pub id: i32,
@@ -26,42 +79,143 @@ pub struct Ticket {
     pub description: String,
     pub room: i16,
     pub status: String,
-    pub date: chrono::NaiveDateTime,
+    pub date: chrono::DateTime<chrono::Utc>,
     pub user_id: i16,
+    pub user_first_name: String,
+    pub user_last_name: String,
 }
 
+/// Properties for components that display a single ticket.
+///
+/// This struct is used to pass the ID of a specific ticket to components
+/// that need to fetch or display its details.
+///
+/// # Fields
+/// - `id`: The unique identifier of the ticket to be displayed.
 #[derive(Properties, PartialEq)]
 pub struct TicketProps {
     pub id: i32,
 }
 
+/// Represents the essential information of the currently authenticated user.
+///
+/// This struct is used to hold a subset of user data relevant for client-side
+/// logic, such as determining if the user is an administrator or filtering
+/// tickets by their ID.
+///
+/// # Fields
+/// - `id`: An `Option<i16>` holding the unique ID of the active user. `None` if not authenticated or ID is unavailable.
+/// - `is_admin`: A boolean indicating if the active user has administrator privileges.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ActiveUser {
+    pub id: Option<i16>,
+    pub is_admin: bool,
+}
+
+/// Represents a standardized error response from the API.
+///
+/// This struct is used to deserialize error messages returned by the backend API,
+/// providing a consistent way to handle and display error information to the user.
+///
+/// # Fields
+/// - `message`: A descriptive error message.
+/// - `_status`: (Ignored) The HTTP status code or a status string from the API.
 #[derive(Deserialize, Debug)]
-pub struct ApiError {
+struct ApiError {
     message: String,
     _status: String,
 }
 
+/// A component that provides a form for users to submit new tickets.
+///
+/// This component allows users to input details such as category, subject (`betreff`),
+/// description, and room number for a new support ticket. It includes client-side
+/// validation for the room number and interacts with the backend API to create the ticket.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `category`, `betreff`, `description`: Values of the form input fields.
+/// - `room`, `room_input`: The parsed and raw room numbers, respectively.
+/// - `status`: To display messages about submission success or errors.
+///
+/// # Room Input Handling
+/// The `room_change` callback handles parsing the room input:
+/// - Supports numerical room numbers (e.g., "101").
+/// - Supports 'K' prefixed rooms (e.g., "K1" parses to -1).
+/// - Supports 'D' prefixed rooms (e.g., "D1" parses to 1001).
+/// - Validates the parsed room against the `VALID_ROOMS` constant.
+///
+/// # Form Submission
+/// - Prevents default form submission behavior.
+/// - Performs validation for room number and presence in `VALID_ROOMS`.
+/// - Constructs a `TicketCreateScheme` payload.
+/// - Sends a POST request to `/api/tickets/create`.
+/// - Updates the `status` state based on the API response.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <SubmitTicket />
+/// }
+/// ```
 #[component(SubmitTicket)]
 pub fn submit_ticket_component() -> Html {
     let category = use_state(|| "".to_string());
     let betreff = use_state(|| "".to_string());
     let description = use_state(|| "".to_string());
-    let room = use_state(|| 0i16);
+    let room = use_state(|| None::<i16>);
+    let room_input = use_state(|| "".to_string());
     let status = use_state(|| None::<String>);
 
+    let valid_rooms: HashSet<i16> = VALID_ROOMS.iter().copied().collect();
+
+    {
+        let message = "Bevor sie zum Support weitergeleitet werden prüfen sie ob: 
+- Ob das Problem durch Neustarten gelößt wird 
+- Ob sie die richtigen Anmeldedaten genutzt habem 
+- Alle notwendigen Kabel eingesteckt sind
+
+Wenn es funktioniert hat klicken sie bitte \"Abbrechen\""
+            .to_string();
+        use_effect(move || {
+            if let Some(win) = web_sys::window() {
+                let _ = if win.confirm_with_message(&message).unwrap() {
+                } else {
+                    spawn_local(async move {
+                        let _ = Request::post("/api/count")
+                            .credentials(web_sys::RequestCredentials::Include)
+                            .send()
+                            .await;
+                    });
+                    let _ = win.location().set_href("/");
+                };
+            }
+            || ()
+        });
+    }
+
     let onsubmit = {
         let category = category.clone();
         let betreff = betreff.clone();
         let description = description.clone();
         let room = room.clone();
         let status = status.clone();
+        let valid_rooms = valid_rooms.clone();
 
         Callback::from(move |e: SubmitEvent| {
             e.prevent_default();
+            if room.is_none() {
+                status.set(Some("Invalid room".into()));
+                return;
+            }
             let category = (*category).clone();
             let betreff = (*betreff).clone();
             let description = (*description).clone();
-            let room = *room;
+            let room = room.unwrap();
+            if !valid_rooms.contains(&room) {
+                status.set(Some("Room not allowed".into()));
+                return;
+            }
             let status = status.clone();
 
             spawn_local(async move {
@@ -73,6 +227,8 @@ pub fn submit_ticket_component() -> Html {
                 };
 
                 let request = Request::post("/api/tickets/create")
+                    .header("Content-Type", "application/json")
+                    .credentials(web_sys::RequestCredentials::Include)
                     .json(&payload)
                     .expect("Failed to build request");
 
@@ -111,22 +267,62 @@ pub fn submit_ticket_component() -> Html {
 
     let room_change = {
         let room = room.clone();
+        let room_input = room_input.clone();
         Callback::from(move |e: InputEvent| {
             let input: web_sys::HtmlInputElement = e.target_unchecked_into();
-            room.set(input.value().parse().unwrap_or(0));
+            let raw = input.value();
+            room_input.set(raw.clone());
+
+            let parsed_value: Option<i16> = if raw.trim().is_empty() {
+                None
+            } else {
+                let raw_trim = raw.trim();
+                if raw_trim.len() > 1 && (raw_trim.starts_with('K') || raw_trim.starts_with('k')) {
+                    match raw_trim[1..].parse::<i16>() {
+                        Ok(n) => Some(-n),
+                        Err(_) => None,
+                    }
+                } else if raw_trim.len() > 1
+                    && (raw_trim.starts_with('D') || raw_trim.starts_with('d'))
+                {
+                    match raw_trim[1..].parse::<i16>() {
+                        Ok(n) => Some(1000 + n),
+                        Err(_) => None,
+                    }
+                } else {
+                    match raw_trim.parse::<i16>() {
+                        Ok(n) => Some(n),
+                        Err(_) => None,
+                    }
+                }
+            };
+
+            if let Some(v) = parsed_value {
+                if !valid_rooms.contains(&v) {
+                    room.set(None);
+                } else {
+                    room.set(Some(v));
+                }
+            } else {
+                room.set(None);
+            }
         })
     };
 
+    let room_valid = (*room).is_some();
+
     html! {
+        <div class="form-container">
+            <div class="page-header">
+                <h1>{ "Create Ticket" }</h1>
+            </div>
             <form {onsubmit}>
                 <label>{ "Betreff:" }
                     <input type="text" value={(*betreff).clone()} oninput={betreff_change}/>
                 </label>
-            <br/>
                 <label>{ "Beschreibung:" }
-                <input type="text" value={(*description).clone()} oninput={description_change}/>
+                    <textarea value={(*description).clone()} oninput={description_change}/>
                 </label>
-            <br/>
                 <label>{ "Kategorie:" }
                     <select value={(*category).clone()} onchange={category_change}>
                         <option value="Whiteboard Beamer">{ "Whiteboard Beamer" }</option>
@@ -137,27 +333,71 @@ pub fn submit_ticket_component() -> Html {
                         <option value="Sonstiges">{ "Sonstiges" }</option>
                     </select>
                 </label>
-            <br/>
                 <label>{ "Raum:" }
-                <input type="number" value={room.to_string()} oninput={room_change}/>
+                    <input type="text" value={(*room_input).clone()} oninput={room_change}/>
                 </label>
-            <br/>
+                {
+                    if !room_valid {
+                        html! {
+                            <p class="alert error">{ "Ungültiger oder nicht erlaubter Raum (z. B. 101, K8, D1)" }</p>
+                        }
+                    } else {
+                        html! {}
+                    }
+                }
                 <button type="submit">{ "Send" }</button>
 
+                <Link<crate::Route> to={crate::Route::AllTickets}>{ "View All Tickets" }</Link<crate::Route>>
+
                 {
                     if let Some(s) = &*status {
-                    html!{ <p>{ s }</p> }
+                        html!{ <p class="alert success">{ s }</p> }
                     } else {
                         html!{}
                     }
                 }
 
             </form>
+        </div>
     }
 }
 
-#[component(ShowTicketByID)]
-pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
+/// A component for displaying, updating, and deleting a single ticket by its ID.
+///
+/// This component fetches a specific ticket's details from the backend based on the
+/// `id` provided in its `TicketProps`. It allows administrators to update the ticket's
+/// status and delete the ticket.
+///
+/// # Props
+/// - `id`: The `i32` ID of the ticket to fetch and display.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `ticket`: The fetched [`Ticket`] data, if available.
+/// - `error`: Any error message encountered during API calls.
+/// - `loading`: A boolean indicating if data is currently being fetched.
+/// - `status`: The selected status for updating the ticket.
+/// - `deleting`: A boolean indicating if a delete operation is in progress.
+/// - `delete_error`: Any error message from a delete operation.
+///
+/// # Functionality
+/// - **Data Fetching**: On component mount or `id` change, fetches ticket data from
+///   `/api/tickets/:id`.
+/// - **Status Update**: Provides a dropdown to change the ticket's status. Submitting the
+///   form sends a PATCH request to `/api/tickets/:id` with a `TicketUpdateScheme` payload.
+/// - **Ticket Deletion**: Includes a "Delete" button that, after user confirmation,
+///   sends a DELETE request to `/api/tickets/:id`. On success, clears the ticket from display.
+/// - **Error Handling**: Displays error messages for network issues, API errors, or parsing failures.
+/// - **Date Formatting**: Displays the ticket creation date formatted to `Europe/Berlin` timezone.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <TicketByID id={123} />
+/// }
+/// ```
+#[component(TicketByID)]
+pub fn ticket_by_id_component(props: &TicketProps) -> Html {
     let ticket = use_state(|| None::<Ticket>);
     let error = use_state(|| None::<String>);
     let loading = use_state(|| false);
@@ -242,6 +482,52 @@ pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
         })
     };
 
+    let deleting = use_state(|| false);
+    let delete_error = use_state(|| None::<String>);
+
+    let ondelete = {
+        let deleting = deleting.clone();
+        let delete_error = delete_error.clone();
+        let ticket_state = ticket.clone();
+        let id = id;
+
+        Callback::from(move |e: MouseEvent| {
+            e.prevent_default();
+            if !web_sys::window()
+                .and_then(|w| w.confirm_with_message("Sicher löschen?").ok())
+                .unwrap_or(false)
+            {
+                return;
+            }
+
+            deleting.set(true);
+            delete_error.set(None);
+
+            let deleting = deleting.clone();
+            let delete_error = delete_error.clone();
+            let ticket_state = ticket_state.clone();
+
+            spawn_local(async move {
+                let url = format!("/api/tickets/{}", id);
+                let request =
+                    Request::delete(&url).credentials(web_sys::RequestCredentials::Include);
+
+                match request.send().await {
+                    Ok(resp) if resp.status() == 200 || resp.status() == 204 => {
+                        // remove local state or navigate away
+                        ticket_state.set(None); // clears the shown item
+                    }
+                    Ok(resp) => {
+                        let txt = resp.text().await.unwrap_or_else(|_| "Unknown".into());
+                        delete_error.set(Some(format!("HTTP {}: {}", resp.status(), txt)));
+                    }
+                    Err(err) => delete_error.set(Some(format!("Network error: {}", err))),
+                }
+                deleting.set(false);
+            });
+        })
+    };
+
     if *loading {
         html! {<p>{ "Loading" }</p>}
     } else if let Some(e) = &*error {
@@ -254,7 +540,9 @@ pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
                 <p><strong>{ "Betreff: " }</strong>{ &t.betreff }</p>
                 <p><strong>{ "Beschreibung: " }</strong>{ &t.description }</p>
                 <p><strong>{ "Raum: " }</strong>{ t.room }</p>
-                <p><strong>{ "Datum: " }</strong>{ &t.date }</p>
+                <p><strong>{ "Datum: " }</strong>{
+                    t.date.with_timezone(&Berlin).format("%d.%m.%Y %H:%M:%S").to_string()
+                }</p>
                 <p><strong>{ "Status: "}</strong>{ match t.status.as_str() {
                     "ToDo" => "Zu tun",
                     "InProgress" => "In Bearbeitung",
@@ -262,6 +550,7 @@ pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
                     "Archived" => "Archiviert",
                     _ => "Ungültiger Status"
                 }}</p>
+                <p><strong>{ "Name: "}</strong>{ format!{"{} {}", t.user_first_name, t.user_last_name } }</p>
 
                 <form {onsubmit}>
                     <label>{ "Status ändern" }
@@ -274,6 +563,15 @@ pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
                     </label>
                     <button type="submit">{ "Aktualisieren" }</button>
                 </form>
+
+                <button onclick={ondelete} disabled={*deleting}>
+                    {if *deleting {"Löschen..."} else {"Löschen"}}
+                </button>
+
+                <Link<crate::Route> to={crate::Route::AllTickets}>{ "Zurück zur Ticketübersicht" }</Link<crate::Route>>
+                if let Some(err) = &*delete_error {
+                    <p style="color:red">{ err.clone() }</p>
+                }
             </div>
         }
     } else {
@@ -281,11 +579,48 @@ pub fn show_ticket_by_id_component(props: &TicketProps) -> Html {
     }
 }
 
+/// A component for fetching and displaying a list of all tickets.
+///
+/// This component retrieves all tickets from the backend and presents them as a list.
+/// It dynamically filters the displayed tickets based on the current user's role:
+/// administrators see all tickets, while regular users only see tickets they created.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `tickets`: A vector of `Ticket` structs to store the fetched tickets.
+/// - `error`: Any error message encountered during API calls.
+/// - `loading`: A boolean indicating if data is currently being fetched.
+/// - `user`: An `ActiveUser` struct holding the current user's ID and admin status.
+///
+/// # Functionality
+/// - **Fetch Tickets**: On component mount, fetches all tickets from `/api/tickets`.
+/// - **Fetch Current User**: Concurrently fetches the current user's details from
+///   `/api/users/current` to determine their `user_id` and `is_admin` status.
+/// - **Conditional Display**:
+///   - If `loading` is true, displays "Loading...".
+///   - If an `error` occurs, displays the error message.
+///   - Otherwise, renders a list of tickets.
+/// - **Filtering**:
+///   - Administrators (`user.is_admin = true`) see all tickets.
+///   - Regular users (`user.is_admin = false`) only see tickets where `t.user_id == user.id`.
+/// - **Navigation**: Each ticket in the list is a link to [`crate::Route::TicketById`]
+///   for viewing individual ticket details.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <AllTickets />
+/// }
+/// ```
 #[component(AllTickets)]
 pub fn all_tickets_component() -> Html {
     let tickets = use_state(|| Vec::<Ticket>::new());
     let error = use_state(|| None::<String>);
     let loading = use_state(|| false);
+    let user = use_state(|| ActiveUser {
+        id: None,
+        is_admin: false,
+    });
 
     {
         let tickets = tickets.clone();
@@ -318,20 +653,200 @@ pub fn all_tickets_component() -> Html {
         });
     }
 
+    {
+        let user = user.clone();
+        use_effect_with((), move |_| {
+            let user = user.clone();
+            spawn_local(async move {
+                if let Ok(response) = Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await
+                {
+                    if response.status() == 200 {
+                        if let Ok(json) = response.json::<serde_json::Value>().await {
+                            let id = json
+                                .get("data")
+                                .and_then(|d| d.get("id"))
+                                .and_then(|v| v.as_i64())
+                                .and_then(|n| i16::try_from(n).ok());
+                            let is_admin = json
+                                .get("data")
+                                .and_then(|d| d.get("is_admin"))
+                                .and_then(|v| v.as_bool())
+                                .unwrap_or(false);
+                            user.set(ActiveUser { id, is_admin });
+                        }
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
     if *loading {
         html! {<p>{ "Loading" }</p>}
     } else if let Some(e) = &*error {
         html! { <p>{ format!("Error: {}", e) }</p> }
     } else {
         html! {
-            <ul>
-            { for tickets.iter().map(|t| html! {
-                    <li key={t.id.to_string()}>
-                        <h3>{ format!("{} - #{}", t.betreff, t.id) }</h3>
+            <div>
+                <div class="page-header">
+                    <h1>{ "All Tickets" }</h1>
+                </div>
+                <ul class="ticket-list">
+                { for tickets.iter().filter(|t| t.status != "Archived" && (if user.is_admin { true } else if let Some(uid) = user.id { t.user_id == uid } else { false })).map(|t| {
+                        let status_class = match t.status.as_str() {
+                            "ToDo" => "To-Do",
+                            "InProgress" => "InProgress",
+                            "Completed" => "Completed",
+                            "Archived" => "Archived",
+                            _ => "To-Do"
+                        };
+                        html! {
+                            <li key={t.id.to_string()} class={status_class}>
+                                <Link<crate::Route> to={crate::Route::TicketById{id: t.id}}><h3>{ format!("{}", t.betreff) }</h3></Link<crate::Route>>
                                 <p>{ &t.description }</p>
                             </li>
+                        }
                     })}
                 </ul>
+                <div class="ticket-list-actions">
+                    <Link<crate::Route> to={crate::Route::Ticket}>{ "Zurück zur Startseite" }</Link<crate::Route>>
+                </div>
+            </div>
+        }
+    }
+}
+
+/// A component for fetching and displaying a list of archived tickets.
+///
+/// This component retrieves all tickets from the backend and presents them as a list,
+/// filtered to only show those with "Archived" status.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `tickets`: A vector of `Ticket` structs to store the fetched tickets.
+/// - `error`: Any error message encountered during API calls.
+/// - `loading`: A boolean indicating if data is currently being fetched.
+/// - `user`: An `ActiveUser` struct holding the current user's ID and admin status.
+///
+/// # Functionality
+/// - **Fetch Tickets**: On component mount, fetches all tickets from `/api/tickets`.
+/// - **Fetch Current User**: Concurrently fetches the current user's details from
+///   `/api/users/current` to determine their `user_id` and `is_admin` status.
+/// - **Conditional Display**:
+///   - If `loading` is true, displays "Loading...".
+///   - If an `error` occurs, displays the error message.
+///   - Otherwise, renders a list of tickets.
+/// - **Filtering**:
+///   - Only tickets with `t.status == "Archived"` are displayed.
+///   - If the user is an admin, all archived tickets are shown.
+///   - If the user is not an admin, only their own archived tickets are shown.
+/// - **Navigation**: Each ticket in the list is a link to [`crate::Route::TicketById`]
+///   for viewing individual ticket details.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <ArchivedTickets />
+/// }
+/// ```
+#[component(ArchivedTickets)]
+pub fn archived_tickets_component() -> Html {
+    let tickets = use_state(|| Vec::<Ticket>::new());
+    let error = use_state(|| None::<String>);
+    let loading = use_state(|| false);
+    let user = use_state(|| ActiveUser {
+        id: None,
+        is_admin: false,
+    });
+
+    {
+        let tickets = tickets.clone();
+        let error = error.clone();
+        let loading = loading.clone();
+
+        use_effect_with((), move |_| {
+            loading.set(true);
+            spawn_local(async move {
+                let url = format!("/api/tickets");
+                match Request::get(&url).send().await {
+                    Ok(response) if response.status() == 200 => {
+                        match response.json::<Vec<Ticket>>().await {
+                            Ok(t) => tickets.set(t),
+                            Err(e) => error.set(Some(format!("parse error: {}", e))),
+                        }
+                    }
+                    Ok(response) => {
+                        if let Ok(text) = response.text().await {
+                            error.set(Some(text));
+                        } else {
+                            error.set(Some(format!("status {}", response.status())));
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("Network error: {}", err))),
+                }
+                loading.set(false);
+            });
+            || ()
+        });
+    }
+
+    {
+        let user = user.clone();
+        use_effect_with((), move |_| {
+            let user = user.clone();
+            spawn_local(async move {
+                if let Ok(response) = Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await
+                {
+                    if response.status() == 200 {
+                        if let Ok(json) = response.json::<serde_json::Value>().await {
+                            let id = json
+                                .get("data")
+                                .and_then(|d| d.get("id"))
+                                .and_then(|v| v.as_i64())
+                                .and_then(|n| i16::try_from(n).ok());
+                            let is_admin = json
+                                .get("data")
+                                .and_then(|d| d.get("is_admin"))
+                                .and_then(|v| v.as_bool())
+                                .unwrap_or(false);
+                            user.set(ActiveUser { id, is_admin });
+                        }
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
+    if *loading {
+        html! {<p>{ "Loading" }</p>}
+    } else if let Some(e) = &*error {
+        html! { <p>{ format!("Error: {}", e) }</p> }
+    } else {
+        html! {
+            <div>
+                <div class="page-header">
+                                <h1>{ "Archivierte Tickets" }</h1>
+                            </div>
+                <ul class="ticket-list">
+                { for tickets.iter().filter(|t| t.status == "Archived" && (user.is_admin || if let Some(uid) = user.id { t.user_id == uid } else { false })).map(|t| html! {
+                        <div>
+
+                            <li key={t.id.to_string()}>
+                                <Link<crate::Route> to={crate::Route::TicketById{id: t.id}}><h3>{ format!("{}", t.betreff) }</h3></Link<crate::Route>>
+                                <p>{ &t.description }</p>
+                            </li>
+
+                        </div>
+                    })}
+                </ul>
+            </div>
         }
     }
 }

frontend/src/pages/user.rs

@@ -2,17 +2,29 @@ use gloo_net::http::Request;
 use serde::{Deserialize, Serialize};
 use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
+use yew_router::prelude::*;
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct User {
-    pub id: i16,
-    pub last_name: String,
-    pub first_name: String,
-    pub username: String,
-    pub is_admin: bool,
-    pub pwd: String,
-}
+// #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+// pub struct User {
+//     pub id: i16,
+//     pub last_name: String,
+//     pub first_name: String,
+//     pub username: String,
+//     pub is_admin: bool,
+//     pub pwd: String,
+// }
 
+/// Data transfer object (DTO) for creating a new user.
+///
+/// This struct defines the payload sent to the backend when an administrator
+/// registers a new user. It includes all necessary information for user creation.
+///
+/// # Fields
+/// - `first_name`: The first name of the user.
+/// - `last_name`: The last name of the user.
+/// - `username`: The unique username for the user's login.
+/// - `is_admin`: A boolean indicating whether the new user should have administrator privileges.
+/// - `pwd`: The password for the user's account. This will be hashed on the backend.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct UserCreateScheme {
     pub first_name: String,
@@ -22,12 +34,53 @@ pub struct UserCreateScheme {
     pub pwd: String,
 }
 
+/// Data transfer object (DTO) for user login credentials.
+///
+/// This struct defines the payload sent to the backend when a user attempts to log in.
+///
+/// # Fields
+/// - `username`: The username provided by the user.
+/// - `pwd`: The password provided by the user.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct LoginScheme {
     pub username: String,
     pub pwd: String,
 }
 
+/// Data transfer object (DTO) for updating an existing user's information.
+///
+/// This struct is used to send updated user details, including an optional new password,
+/// to the backend for an existing user.
+///
+/// # Fields
+/// - `id`: The unique identifier of the user to be updated.
+/// - `first_name`: The updated first name of the user.
+/// - `last_name`: The updated last name of the user.
+/// - `username`: The updated username for the user.
+/// - `make_admin`: A boolean indicating whether to grant/revoke administrator privileges.
+/// - `new_pwd`: An optional new password for the user. If empty, the password remains unchanged.
+#[derive(Deserialize, Serialize, Debug)]
+pub struct UserUpdateScheme {
+    pub id: i16,
+    pub first_name: String,
+    pub last_name: String,
+    pub username: String,
+    pub make_admin: bool,
+    pub new_pwd: String,
+}
+
+/// Represents a user entity with sensitive information filtered out.
+///
+/// This struct is used for displaying user information in contexts where
+/// the password hash or other sensitive details are not needed or should not be exposed.
+/// It's typically used for listing users or displaying user profiles.
+///
+/// # Fields
+/// - `id`: The unique identifier of the user.
+/// - `first_name`: The first name of the user.
+/// - `last_name`: The last name of the user.
+/// - `username`: The unique username of the user.
+/// - `is_admin`: A boolean indicating if the user has administrator privileges.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct FilteredUser {
     pub id: i16,
@@ -37,6 +90,49 @@ pub struct FilteredUser {
     pub is_admin: bool,
 }
 
+/// Properties for components that display or interact with a single user.
+///
+/// This struct is used to pass the ID of a specific user to components
+/// that need to fetch, display, or modify their details.
+///
+/// # Fields
+/// - `id`: The unique identifier of the user to be displayed or acted upon.
+#[derive(Properties, PartialEq)]
+pub struct UserProps {
+    pub id: i16,
+}
+
+#[derive(Deserialize, Debug)]
+struct ApiError {
+    message: String,
+    _status: String,
+}
+
+/// A component providing a form for registering new users.
+///
+/// This component allows an administrator to create new user accounts by providing
+/// their first name, last name, username, password, and specifying if they should
+/// be an administrator. The component handles form input, validation (basic),
+/// and interaction with the backend `/api/register` endpoint.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `first_name`, `last_name`, `username`, `pwd`: Values of the form input fields.
+/// - `is_admin`: Boolean state for the admin checkbox.
+/// - `status`: To display messages about registration success or errors.
+///
+/// # Form Submission
+/// - Prevents default form submission behavior.
+/// - Constructs a `UserCreateScheme` payload from the form data.
+/// - Sends a POST request to `/api/register`.
+/// - Updates the `status` state based on the API response.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <Register />
+/// }
+/// ```
 #[component(Register)]
 pub fn register_component() -> Html {
     let first_name = use_state(|| "".to_string());
@@ -126,6 +222,10 @@ pub fn register_component() -> Html {
     };
 
     html! {
+        <div class="form-container">
+            <div class="page-header">
+                <h1>{ "Register User" }</h1>
+            </div>
             <form {onsubmit}>
                 <label>{ "Vorname:" }
                     <input type="text" value={(*first_name).clone()} oninput={fn_change}/>
@@ -144,5 +244,541 @@ pub fn register_component() -> Html {
                 </label>
                 <button type="submit">{ "Bestätigen" }</button>
             </form>
+        </div>
+    }
+}
+
+/// A component providing a form for user login.
+///
+/// This component handles user authentication by collecting a username and password,
+/// then sending these credentials to the backend `/api/login` endpoint. It manages
+/// UI states for loading, errors, and success, and redirects to the home page on successful login.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `username`, `pwd`: Values of the login form input fields.
+/// - `loading`: A boolean to indicate if the login process is ongoing.
+/// - `error`: A string to display any login error messages.
+/// - `success`: A boolean to indicate if login was successful.
+///
+/// # Form Submission
+/// - Prevents default form submission behavior.
+/// - Constructs a `LoginScheme` payload from the input fields.
+/// - Sends a POST request to `/api/login`.
+/// - On successful response (HTTP 200), sets `success` to true and redirects to `crate::Route::Home`.
+/// - On error, updates the `error` state with the appropriate message.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <Login />
+/// }
+/// ```
+#[component(Login)]
+pub fn login_component() -> Html {
+    let username = use_state(|| "".to_string());
+    let pwd = use_state(|| "".to_string());
+    let loading = use_state(|| false);
+    let error = use_state(|| String::new());
+    let success = use_state(|| false);
+    let navigator = use_navigator().unwrap();
+
+    let onsubmit = {
+        let username = username.clone();
+        let pwd = pwd.clone();
+        let loading = loading.clone();
+        let error = error.clone();
+        let success = success.clone();
+        let navigator = navigator.clone();
+
+        Callback::from(move |e: SubmitEvent| {
+            e.prevent_default();
+            let username = (*username).clone();
+            let pwd = (*pwd).clone();
+            let loading = loading.clone();
+            let error = error.clone();
+            let success = success.clone();
+            let navigator = navigator.clone();
+
+            loading.set(true);
+            error.set(String::new());
+            success.set(false);
+
+            spawn_local(async move {
+                let payload = LoginScheme { username, pwd };
+
+                let response = Request::post("/api/login")
+                    .header("Content-Type", "application/json")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .json(&payload)
+                    .unwrap()
+                    .send()
+                    .await;
+
+                loading.set(false);
+
+                match response {
+                    Ok(r) if r.status() == 200 => {
+                        success.set(true);
+                        navigator.push(&crate::Route::Home);
+                    }
+                    Ok(r) => {
+                        let text = r.text().await.unwrap_or_else(|_| "unknown".into());
+                        error.set(format!("HTTP {}: {}", r.status(), text));
+                    }
+                    Err(err) => error.set(format!("Network error: {}", err)),
+                }
+            });
+        })
+    };
+
+    html! {
+        <main class="content">
+            <div class="form-container">
+                <div class="page-header">
+                    <h1>{ "Login" }</h1>
+                </div>
+                <form {onsubmit}>
+                    <input
+                        placeholder="username"
+                        value={(*username).clone()}
+                        oninput={Callback::from(move |e: InputEvent| {
+                            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                            username.set(input.value());
+                        })}
+                    />
+                    <input
+                        type="password"
+                        placeholder="password"
+                        value={(*pwd).clone()}
+                        oninput={Callback::from(move |e: InputEvent| {
+                            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                            pwd.set(input.value());
+                        })}
+                    />
+                    <button type="submit" disabled={*loading}>{ if *loading { "Logging in..." } else { "Login" } }</button>
+                    if !error.is_empty() { <p class="alert error">{(*error).clone()}</p> }
+                </form>
+            </div>
+        </main>
+    }
+}
+
+/// A component for fetching and displaying a list of all registered users.
+///
+/// This component retrieves a list of `FilteredUser` entities from the backend
+/// via the `/api/users` endpoint and displays them. Each user entry includes a
+/// link to view their individual details through `UserByID`.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `users`: A vector of `FilteredUser` structs to store the fetched user data.
+/// - `error`: Any error message encountered during API calls.
+/// - `loading`: A boolean indicating if user data is currently being fetched.
+///
+/// # Functionality
+/// - **Data Fetching**: On component mount, fetches all users from `/api/users`.
+/// - **Conditional Display**:
+///   - If `loading` is true, displays "Loading...".
+///   - If an `error` occurs, displays the error message.
+///   - Otherwise, renders an unordered list of users.
+/// - **Navigation**: Each user in the list is a link to [`crate::Route::UserByID`]
+///   for viewing individual user details.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <AllUsers />
+/// }
+/// ```
+#[component(AllUsers)]
+pub fn all_users_component() -> Html {
+    let users = use_state(|| Vec::<FilteredUser>::new());
+    let error = use_state(|| None::<String>);
+    let loading = use_state(|| false);
+
+    {
+        let users = users.clone();
+        let error = error.clone();
+        let loading = loading.clone();
+
+        use_effect_with((), move |_| {
+            loading.set(true);
+            spawn_local(async move {
+                let url = format!("/api/users");
+                match Request::get(&url).send().await {
+                    Ok(response) if response.status() == 200 => {
+                        match response.json::<Vec<FilteredUser>>().await {
+                            Ok(u) => users.set(u),
+                            Err(err) => error.set(Some(format!("Parse error: {}", err))),
+                        }
+                    }
+                    Ok(response) => {
+                        if let Ok(text) = response.text().await {
+                            error.set(Some(text));
+                        } else {
+                            error.set(Some(format!("status {}", response.status())));
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("Network error: {}", err))),
+                }
+                loading.set(false);
+            });
+            || ()
+        });
+    }
+
+    if *loading {
+        html! {
+            <div class="form-container">
+                <div class="page-header">
+                    <h1>{ "All Users" }</h1>
+                </div>
+                <p>{ "Loading..." }</p>
+            </div>
+        }
+    } else if let Some(e) = &*error {
+        html! {
+            <div class="form-container">
+                <div class="page-header">
+                    <h1>{ "All Users" }</h1>
+                </div>
+                <p class="alert error">{ format!("Error: {}", e) }</p>
+            </div>
+        }
+    } else {
+        html! {
+            <div class="form-container">
+                <div class="page-header">
+                    <h1>{ "All Users" }</h1>
+                </div>
+                <ul class="user-list">
+                { for users.iter().map(|t| html! {
+                        <li key={t.id.to_string()}>
+                            <Link<crate::Route> to={crate::Route::UserByID{id: t.id}}><h3>{ format!("{} {}", t.first_name, t.last_name) }</h3></Link<crate::Route>>
+                        </li>
+                    })}
+                </ul>
+            </div>
+        }
+    }
+}
+
+/// A component for displaying, updating, and deleting a single user by their ID.
+///
+/// This component fetches a specific user's details from the backend based on the
+/// `id` provided in its `UserProps`. It allows administrators to view, modify
+/// (first name, last name, username, admin status, and password), and delete user accounts.
+///
+/// # Props
+/// - `id`: The `i16` ID of the user to fetch and display.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `user`: The fetched [`FilteredUser`] data, if available.
+/// - `error`: Any error message encountered during initial user data fetching.
+/// - `loading`: A boolean indicating if initial user data is being fetched.
+/// - `first_name`, `last_name`, `username`, `make_admin`, `new_pwd`:
+///   States for the update form fields, pre-filled with current user data.
+/// - `saving`, `save_error`, `save_success`: States for the user update operation.
+/// - `deleting`, `delete_error`: States for the user deletion operation.
+///
+/// # Functionality
+/// - **Initial Data Fetching**: On component mount or `id` change, fetches user data from
+///   `/api/users/:id`.
+/// - **Form Initialization**: Populates the update form fields with the fetched user's
+///   current details once loaded.
+/// - **User Update**: The update form sends a PATCH request to `/api/users/:id` with a
+///   `UserUpdateScheme` payload. On success, updates the displayed user data and shows a
+///   success message.
+/// - **User Deletion**: Includes a "Delete" button that, after user confirmation, sends
+///   a DELETE request to `/api/users/:id`. On success, clears the user from display.
+/// - **Error Handling**: Displays error messages for various API and network issues.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <UserByID id={42} />
+/// }
+/// ```
+#[component(UserByID)]
+pub fn user_by_id_component(props: &UserProps) -> Html {
+    let user = use_state(|| None::<FilteredUser>);
+    let error = use_state(|| None::<String>);
+    let loading = use_state(|| false);
+    let id = props.id;
+
+    {
+        let user = user.clone();
+        let error = error.clone();
+        let loading = loading.clone();
+
+        use_effect_with(id, move |id_ref| {
+            loading.set(true);
+            let user = user.clone();
+            let error = error.clone();
+            let id = *id_ref;
+            spawn_local(async move {
+                let url = format!("/api/users/{}", id);
+
+                match Request::get(&url).send().await {
+                    Ok(response) => {
+                        let status = response.status();
+                        if status == 200 {
+                            match response.json::<FilteredUser>().await {
+                                Ok(u) => user.set(Some(u)),
+                                Err(err) => error.set(Some(format!("Parse error: {}", err))),
+                            }
+                        } else {
+                            match response.json::<ApiError>().await {
+                                Ok(ae) => error.set(Some(ae.message)),
+                                Err(_) => {
+                                    if let Ok(text) = response.text().await {
+                                        error.set(Some(text));
+                                    } else {
+                                        error.set(Some(format!("Server error: {}", status)));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("Network error: {}", err))),
+                }
+                loading.set(false);
+            });
+            || ()
+        });
+    }
+
+    let first_name = use_state(|| "".to_string());
+    let last_name = use_state(|| "".to_string());
+    let username = use_state(|| "".to_string());
+    let make_admin = use_state(|| false);
+    let new_pwd = use_state(|| String::new());
+    let saving = use_state(|| false);
+    let save_error = use_state(|| None::<String>);
+    let save_success = use_state(|| false);
+
+    {
+        let user = user.clone();
+        let first_name = first_name.clone();
+        let last_name = last_name.clone();
+        let username = username.clone();
+        let make_admin = make_admin.clone();
+
+        use_effect_with(user, move |user_ref| {
+            if let Some(u) = &**user_ref {
+                first_name.set(u.first_name.clone());
+                last_name.set(u.last_name.clone());
+                username.set(u.username.clone());
+                make_admin.set(u.is_admin);
+            }
+            || ()
+        });
+    }
+
+    let onsubmit = {
+        let first_name = first_name.clone();
+        let last_name = last_name.clone();
+        let username = username.clone();
+        let make_admin = make_admin.clone();
+        let new_pwd = new_pwd.clone();
+        let saving = saving.clone();
+        let save_error = save_error.clone();
+        let save_success = save_success.clone();
+        let user_state = user.clone();
+
+        Callback::from(move |e: SubmitEvent| {
+            e.prevent_default();
+            let first_name = (*first_name).clone();
+            let last_name = (*last_name).clone();
+            let username = (*username).clone();
+            let make_admin = *make_admin;
+            let new_pwd = (*new_pwd).clone();
+
+            saving.set(true);
+            save_error.set(None);
+            save_success.set(false);
+
+            let saving = saving.clone();
+            let save_error = save_error.clone();
+            let save_success = save_success.clone();
+            let user_state = user_state.clone();
+            let id = id;
+
+            spawn_local(async move {
+                let payload = UserUpdateScheme {
+                    id: id,
+                    first_name,
+                    last_name,
+                    username,
+                    make_admin,
+                    new_pwd,
+                };
+
+                let url = format!("/api/users/{}", id);
+                let request = Request::patch(&url)
+                    .header("Content-Type", "application/json")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .json(&payload)
+                    .expect("Failed to construct Request");
+
+                match request.send().await {
+                    Ok(resp) if resp.status() == 200 => {
+                        if let Ok(updated) = resp.json::<FilteredUser>().await {
+                            user_state.set(Some(updated));
+                        }
+                        save_success.set(true);
+                    }
+                    Ok(resp) => {
+                        let txt = resp.text().await.unwrap_or_else(|_| "Unknown".into());
+                        save_error.set(Some(format!("HTTP {}: {}", resp.status(), txt)));
+                    }
+                    Err(err) => save_error.set(Some(format!("Network error: {}", err))),
+                }
+                saving.set(false);
+            });
+        })
+    };
+
+    let deleting = use_state(|| false);
+    let delete_error = use_state(|| None::<String>);
+
+    let ondelete = {
+        let deleting = deleting.clone();
+        let delete_error = delete_error.clone();
+        let user_state = user.clone(); // or ticket
+        let id = id;
+
+        Callback::from(move |e: MouseEvent| {
+            e.prevent_default();
+            // confirm
+            if !web_sys::window()
+                .and_then(|w| {
+                    w.confirm_with_message("Are you sure you want to delete this item?")
+                        .ok()
+                })
+                .unwrap_or(false)
+            {
+                return;
+            }
+
+            deleting.set(true);
+            delete_error.set(None);
+
+            let deleting = deleting.clone();
+            let delete_error = delete_error.clone();
+            let user_state = user_state.clone();
+
+            spawn_local(async move {
+                let url = format!("/api/users/{}", id); // or /api/tickets/{}
+                let req = Request::delete(&url).credentials(web_sys::RequestCredentials::Include);
+
+                match req.send().await {
+                    Ok(resp) if resp.status() == 200 || resp.status() == 204 => {
+                        // remove local state or navigate away
+                        user_state.set(None); // clears the shown item
+                    }
+                    Ok(resp) => {
+                        let txt = resp.text().await.unwrap_or_else(|_| "Unknown".into());
+                        delete_error.set(Some(format!("HTTP {}: {}", resp.status(), txt)));
+                    }
+                    Err(err) => delete_error.set(Some(format!("Network error: {}", err))),
+                }
+                deleting.set(false);
+            });
+        })
+    };
+
+    if *loading {
+        html! {<p>{ "Loading" }</p>}
+    } else if let Some(e) = &*error {
+        html! { <p>{ format!("Error: {}", e) }</p> }
+    } else if let Some(u) = &*user {
+        html! {
+            <div>
+                <div>
+                    <p><strong>{ "Vorname: " }</strong>{ &u.first_name }</p>
+                    <p><strong>{ "Nachname: " }</strong>{ &u.last_name }</p>
+                    <p><strong>{ "Benutzername: " }</strong>{ &u.username }</p>
+                    <p><strong>{ "Ist Admin: " }</strong>{ u.is_admin }</p>
+                </div>
+
+                <h1>{ format!("User #{}", u.id) }</h1>
+                <form onsubmit={onsubmit}>
+                    <div>
+                        <label>{ "Vorname" }
+                            <input name="first_name"
+                                value={(*first_name).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    first_name.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+                    <div>
+                        <label>{ "Nachname" }
+                            <input name="last_name"
+                                value={(*last_name).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    last_name.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+                    <div>
+                        <label>{ "Benutzername" }
+                            <input name="username"
+                                value={(*username).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    username.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+                    <div>
+                        <label>{ "Ist Admin" }
+                            <input type="checkbox" name="make_admin" checked={*make_admin} onchange={Callback::from(move |e: Event| {
+                                let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                make_admin.set(input.checked());
+                            })}/>
+                        </label>
+                    </div>
+                    <div>
+                        <label>{ "Neues Passwort (leer = unchanged)" }
+                            <input name="new_pwd" type="password"
+                                value={(*new_pwd).clone()}
+                                oninput={Callback::from(move |e: InputEvent| {
+                                    let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                                    new_pwd.set(input.value());
+                                })}
+                            />
+                        </label>
+                    </div>
+
+                    <button type="submit" disabled={*saving}>{ if *saving { "Speichern..." } else { "Speichern" } }</button>
+                    if *save_success {
+                        <p style="color:green">{ "Updated successfully" }</p>
+                    }
+                    if let Some(err) = &*save_error {
+                        <p style="color:red">{ err.clone() }</p>
+                    }
+                </form>
+
+                <button onclick={ondelete} disabled={*deleting}>
+                    {if *deleting {"Löschen..."} else {"Löschen"}}
+                </button>
+
+                <Link<crate::Route> to={crate::Route::AllUsers}>{ "Zurück zur Benutzerübersicht" }</Link<crate::Route>>
+                if let Some(err) = &*delete_error {
+                    <p style="color:red">{ err.clone() }</p>
+                }
+            </div>
+        }
+    } else {
+        html! { <p>{ "No ticket found." }</p> }
     }
 }

frontend/src/pages/utilities.rs

@@ -0,0 +1,639 @@
+use std::collections::HashMap;
+
+use chrono::{DateTime, Datelike, Utc};
+use gloo_net::http::Request;
+use serde::Deserialize;
+use wasm_bindgen_futures::spawn_local;
+use yew::prelude::*;
+
+use crate::dequote;
+use crate::pages::ticket::{ActiveUser, Ticket};
+
+/// The response struct for the [EasyFixCount]
+#[derive(Deserialize)]
+struct CountResponse {
+    value: i64,
+}
+
+/// A partial representation of a ticket, containing only the fields necessary for statistical analysis.
+///
+/// This struct is used to efficiently retrieve and process ticket data for diagnostics
+/// without fetching the full ticket details.
+///
+/// # Fields
+/// - `date`: The creation date and time of the ticket in UTC.
+/// - `room`: The room number associated with the ticket.
+
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+struct TicketPartial {
+    date: DateTime<Utc>,
+    room: i16,
+    user_id: i16,
+}
+
+/// A partial representation of a user, containing only the fields necessary for statistical analysis.
+///
+/// This struct is used to retrieve and process user data for diagnostics
+///
+/// # Fields
+/// - `id`: The users id
+/// - `first_name`: The users first name
+/// - `last_name`: The users last name
+#[derive(Debug, Deserialize, Clone, PartialEq)]
+struct UserPartial {
+    id: i16,
+    first_name: String,
+    last_name: String,
+}
+
+/// Properties for components that display room-wise ticket totals.
+///
+/// This struct passes a list of partial ticket data to a component responsible
+/// for calculating and visualizing ticket distribution per room.
+///
+/// # Fields
+/// - `tickets`: A vector of `TicketPartial` containing ticket data relevant for room totals.
+#[derive(Properties, PartialEq)]
+struct RoomTotalsProps {
+    tickets: Vec<TicketPartial>,
+}
+
+#[derive(Properties, PartialEq)]
+struct UserTotalProps {
+    users: Vec<UserPartial>,
+    tickets: Vec<TicketPartial>,
+}
+
+/// Converts a `chrono::DateTime<Utc>` object's weekday to a 0-indexed integer.
+///
+/// This function maps `chrono::Weekday` values (where Monday is 1, Sunday is 7)
+/// to a 0-indexed system (Monday = 0, Sunday = 6).
+///
+/// # Arguments
+/// - `dt`: A reference to a `DateTime<Utc>` object.
+///
+/// # Returns
+/// A `usize` representing the weekday index (0 for Monday, ..., 6 for Sunday).
+fn weekday_index(dt: &DateTime<Utc>) -> usize {
+    // chrono::Weekday: Mon = 1 ... Sun = 7
+    match dt.weekday() {
+        chrono::Weekday::Mon => 0,
+        chrono::Weekday::Tue => 1,
+        chrono::Weekday::Wed => 2,
+        chrono::Weekday::Thu => 3,
+        chrono::Weekday::Fri => 4,
+        chrono::Weekday::Sat => 5,
+        chrono::Weekday::Sun => 6,
+    }
+}
+
+/// Counts the number of tickets submitted on each day of the week.
+///
+/// This function takes a slice of `TicketPartial` and returns an array where each
+/// element corresponds to a day of the week (Monday=0, Sunday=6) and contains
+/// the total count of tickets submitted on that day.
+///
+/// # Arguments
+/// - `tickets`: A slice of `TicketPartial` items to count.
+///
+/// # Returns
+/// An array `[usize; 7]` with ticket counts for each weekday.
+fn count_by_weekday(tickets: &[TicketPartial]) -> [usize; 7] {
+    let mut counts = [0usize; 7];
+    for t in tickets {
+        counts[weekday_index(&t.date)] += 1;
+    }
+    counts
+}
+
+/// Calculates the occurrences of each weekday within the date range covered by the tickets.
+///
+/// This function determines the minimum and maximum dates from the provided `TicketPartial`
+/// slice and then counts how many times each weekday occurs within that inclusive date range.
+/// This is useful for normalizing ticket counts against the number of available days for each weekday.
+///
+/// # Arguments
+/// - `partials`: A slice of `TicketPartial` items defining the date range.
+///
+/// # Returns
+/// An array `[usize; 7]` where each element represents the number of times a
+/// specific weekday (Monday=0, ..., Sunday=6) appears in the date range.
+fn day_counts(partials: &[TicketPartial]) -> [usize; 7] {
+    if partials.is_empty() {
+        return [0usize; 7];
+    }
+
+    let mut min = partials[0].date.date_naive();
+    let mut max = min;
+    for d in partials.iter().skip(1) {
+        let dt = d.date.date_naive();
+        if dt < min {
+            min = dt
+        }
+        if dt > max {
+            max = dt
+        }
+    }
+
+    let total_days = (max - min).num_days() + 1;
+    if total_days <= 0 {
+        return [0usize; 7];
+    }
+
+    let mut occ = [0usize; 7];
+    let mut current = min;
+    for _ in 0..total_days {
+        let wd = current.weekday();
+        let idx = match wd {
+            chrono::Weekday::Mon => 0,
+            chrono::Weekday::Tue => 1,
+            chrono::Weekday::Wed => 2,
+            chrono::Weekday::Thu => 3,
+            chrono::Weekday::Fri => 4,
+            chrono::Weekday::Sat => 5,
+            chrono::Weekday::Sun => 6,
+        };
+        occ[idx] += 1;
+        current = current + chrono::Duration::days(1);
+    }
+
+    occ
+}
+
+/// Converts a numerical room representation back into a human-readable string format.
+///
+/// This function is the inverse of the room parsing logic in `SubmitTicket` component.
+/// It converts negative numbers back to "K" prefixed rooms, numbers >= 1000 back to "D" prefixed rooms,
+/// and other numbers to their string representation.
+///
+/// # Arguments
+/// - `r`: An `i16` representing the internal numerical representation of a room.
+///
+/// # Returns
+/// A `String` containing the formatted room number (e.g., "K1", "D1", "101").
+fn parse_room(r: i16) -> String {
+    if r < 0 {
+        format!("K{}", r.abs())
+    } else if r > 1000 {
+        format!("D{}", r - 1000)
+    } else {
+        r.to_string()
+    }
+}
+
+/// The main diagnostics dashboard component.
+///
+/// This component serves as a container for various statistical and diagnostic
+/// views related to the application's tickets.
+///
+/// # Components Rendered
+/// - [`TicketCount`]: Displays the count of open tickets.
+/// - [`SubmitStats`]: Displays statistics related to ticket submissions (e.g., by weekday, by room).
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <Diagnostics />
+/// }
+/// ```
+#[component(Diagnostics)]
+pub fn diagnostics_component() -> Html {
+    html! {
+        <div>
+            <TicketCount/>
+            <EasyFixCount/>
+            <SubmitStats/>
+        </div>
+    }
+}
+
+/// A component that displays the count of currently open (ToDo or InProgress) tickets.
+///
+/// This component fetches all tickets and the current user's details. It then filters
+/// the tickets to count only those that are "ToDo" or "InProgress" and are either
+/// created by the current user (for non-admins) or all tickets (for admins).
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `tickets`: A vector of `Ticket` structs for all fetched tickets.
+/// - `error`: Any error message from API calls.
+/// - `loading`: A boolean indicating if data is being fetched.
+/// - `user`: The `ActiveUser` details for conditional filtering.
+///
+/// # Functionality
+/// - Fetches all tickets from `/api/tickets`.
+/// - Fetches current user details from `/api/users/current`.
+/// - Filters tickets by status ("ToDo" or "InProgress") and user ID (if not admin).
+/// - Displays the count of matching tickets.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <TicketCount />
+/// }
+/// ```
+#[component(TicketCount)]
+pub fn ticket_count_component() -> Html {
+    let tickets = use_state(|| Vec::<Ticket>::new());
+    let error = use_state(|| None::<String>);
+    let loading = use_state(|| false);
+    let user = use_state(|| ActiveUser {
+        id: None,
+        is_admin: false,
+    });
+
+    {
+        let tickets = tickets.clone();
+        let error = error.clone();
+        let loading = loading.clone();
+
+        use_effect_with((), move |_| {
+            loading.set(true);
+            spawn_local(async move {
+                let url = format!("/api/tickets");
+                match Request::get(&url).send().await {
+                    Ok(response) if response.status() == 200 => {
+                        match response.json::<Vec<Ticket>>().await {
+                            Ok(t) => tickets.set(t),
+                            Err(e) => error.set(Some(format!("parse error: {}", e))),
+                        }
+                    }
+                    Ok(response) => {
+                        if let Ok(text) = response.text().await {
+                            error.set(Some(text));
+                        } else {
+                            error.set(Some(format!("status {}", response.status())));
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("Network error: {}", err))),
+                }
+                loading.set(false);
+            });
+            || ()
+        });
+    }
+
+    {
+        let user = user.clone();
+        use_effect_with((), move |_| {
+            let user = user.clone();
+            spawn_local(async move {
+                if let Ok(response) = Request::get("/api/users/current")
+                    .credentials(web_sys::RequestCredentials::Include)
+                    .send()
+                    .await
+                {
+                    if response.status() == 200 {
+                        if let Ok(json) = response.json::<serde_json::Value>().await {
+                            let id = json
+                                .get("data")
+                                .and_then(|d| d.get("id"))
+                                .and_then(|v| v.as_i64())
+                                .and_then(|n| i16::try_from(n).ok());
+                            let is_admin = json
+                                .get("data")
+                                .and_then(|d| d.get("is_admin"))
+                                .and_then(|v| v.as_bool())
+                                .unwrap_or(false);
+                            user.set(ActiveUser { id, is_admin });
+                        }
+                    }
+                }
+            });
+            || ()
+        });
+    }
+
+    if *loading {
+        html! {<p>{ "Loading" }</p>}
+    } else if let Some(e) = &*error {
+        html! { <p>{ format!("Error: {}", e) }</p> }
+    } else {
+        let status_conditions = |t: &Ticket| t.status == "ToDo" || t.status == "InProgress";
+        let count = tickets
+            .iter()
+            .filter(|t| {
+                status_conditions(t)
+                    && (user.is_admin || user.id.map_or(false, |uid| t.user_id == uid))
+            })
+            .count();
+        html! {
+            <div class="open-tickets">
+                <h2 class="left">{ "Offene Tickets" }</h2>
+                <h4 class="ticket_count center">{ count }</h4>
+            </div>
+        }
+    }
+}
+
+/// A component that displays various statistics about ticket submissions.
+///
+/// This component fetches all tickets (in a partial format for efficiency)
+/// and calculates statistics such as tickets per weekday and tickets per room.
+/// It renders these statistics visually using simple bar charts.
+///
+/// # State
+/// Uses `use_state` hooks to manage:
+/// - `tickets`: A vector of `TicketPartial` for statistical analysis.
+/// - `error`: Any error message from API calls.
+/// - `loading`: A boolean indicating if data is being fetched.
+///
+/// # Functionality
+/// - Fetches all tickets (as `TicketPartial`) from `/api/tickets`.
+/// - Calculates:
+///   - `counts`: Number of tickets submitted on each weekday.
+///   - `occ`: Number of occurrences of each weekday in the ticket date range.
+///   - `avg`: Average number of tickets per day for each weekday, normalized by `occ`.
+/// - Renders a bar chart for average tickets per weekday.
+/// - Renders a [`RoomTotalTickets`] component to display tickets per room.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <SubmitStats />
+/// }
+/// ```
+#[component(SubmitStats)]
+pub fn submit_stats_component() -> Html {
+    let tickets = use_state(|| Vec::<TicketPartial>::new());
+    let users = use_state(|| Vec::<UserPartial>::new());
+    let error = use_state(|| None::<String>);
+    let loading = use_state(|| false);
+
+    {
+        let tickets = tickets.clone();
+        let users = users.clone();
+        let error = error.clone();
+        let loading = loading.clone();
+
+        use_effect_with((), move |_| {
+            loading.set(true);
+            spawn_local(async move {
+                let url = "/api/tickets".to_string();
+                match Request::get(&url).send().await {
+                    Ok(response) if response.status() == 200 => {
+                        match response.json::<Vec<TicketPartial>>().await {
+                            Ok(t) => tickets.set(t),
+                            Err(e) => error.set(Some(format!("parse error: {}", e))),
+                        }
+                    }
+                    Ok(response) => {
+                        if let Ok(text) = response.text().await {
+                            error.set(Some(text));
+                        } else {
+                            error.set(Some(format!("status {}", response.status())));
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("Network error: {}", err))),
+                }
+
+                match Request::get("/api/users").send().await {
+                    Ok(response) if response.status() == 200 => {
+                        match response.json::<Vec<UserPartial>>().await {
+                            Ok(u) => users.set(u),
+                            Err(e) => error.set(Some(format!("users parse error: {}", e))),
+                        }
+                    }
+                    Ok(response) => {
+                        if let Ok(text) = response.text().await {
+                            error.set(Some(text));
+                        } else {
+                            error.set(Some(format!("users status {}", response.status())));
+                        }
+                    }
+                    Err(err) => error.set(Some(format!("users network error: {}", err))),
+                }
+
+                loading.set(false);
+            });
+            || ()
+        });
+    }
+
+    let counts = count_by_weekday(&tickets);
+    let occ = day_counts(&tickets);
+
+    let mut avg = [0.0f64; 7];
+    for i in 0..7 {
+        if occ[i] > 0 {
+            avg[i] = counts[i] as f64 / occ[i] as f64;
+        } else {
+            avg[i] = 0.0;
+        }
+    }
+
+    let weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+    let (max_idx, _max_val) = counts
+        .iter()
+        .enumerate()
+        .max_by(|a, b| a.1.partial_cmp(b.1).unwrap())
+        .map(|(i, _)| (i, ()))
+        .unwrap_or((0, ()));
+
+    html! {
+        <div class="diagnostics-section">
+            if *loading {
+                <p>{ "Loading..." }</p>
+            }
+            if let Some(e) = &*error {
+                <p style="color: red;">{ e.clone() }</p>
+            }
+            <h3>{ "Tickets per weekday" }</h3>
+            <div class="weekday-chart">
+                <div class="weekday-bars">
+                    { for (0..7).map(|i| {
+                        let is_max = i == max_idx;
+                        let max_value = counts.iter().cloned().max().unwrap_or(1).max(1);
+                        let bar_height_percent = if max_value > 0 { (avg[i] / max_value as f64) * 100.0 } else { 0.0 };
+                        let bar_height_px = (bar_height_percent * 200.0 / 100.0) as i32;
+                        html! {
+                            <div class="weekday-bar">
+                                <div class={format!("bar{}", if is_max { " max" } else { "" })} style={format!("height: {}px;", bar_height_px)}>
+                                </div>
+                            </div>
+                        }
+                    })}
+                </div>
+                <div class="weekday-labels">
+                    { for (0..7).map(|i| {
+                        html! {
+                            <div class="label-item">
+                                <div class="day">{ weekdays[i] }</div>
+                                <div class="value">{ format!("{:.1}", avg[i]) }</div>
+                            </div>
+                        }
+                    })}
+                </div>
+            </div>
+            <div class="diagnostics-row">
+                <div class="diagnostics-column">
+                    <h3>{ "Tickets pro Raum" }</h3>
+                    <RoomTotalTickets tickets={(*tickets).clone()}/>
+                </div>
+                <div class="diagnostics-column">
+                    <h3>{ "Tickets pro Benutzer" }</h3>
+                    <UserTotal users={(*users).clone()} tickets={(*tickets).clone()}/>
+                </div>
+            </div>
+        </div>
+    }
+}
+
+/// A component that displays the total number of tickets per room.
+///
+/// This component takes a list of [`TicketPartial`] items and calculates the
+/// total number of tickets for each room. It then displays these totals
+/// in a sorted list with a bar chart visualization.
+///
+/// # Props
+/// - `tickets`: A `Vec<TicketPartial>` containing the partial ticket data for analysis.
+///
+/// # Functionality
+/// - **Calculates Totals**: Aggregates ticket counts for each unique room.
+/// - **Sorts Results**: Displays rooms sorted by ticket count in descending order.
+/// - **Visualizes Data**: Renders a bar chart where the width of each bar is
+///   proportional to the ticket count for that room, relative to the room with the maximum tickets.
+/// - **Room Formatting**: Uses the `parse_room` function to display room numbers
+///   in a human-readable format.
+///
+/// # Example
+/// ```rust
+/// html! {
+///     <RoomTotalTickets tickets={my_ticket_partials} />
+/// }
+/// ```
+#[component(RoomTotalTickets)]
+fn room_total_component(props: &RoomTotalsProps) -> Html {
+    let mut totals: HashMap<i16, usize> = HashMap::new();
+    for t in &props.tickets {
+        *totals.entry(t.room).or_insert(0) += 1;
+    }
+
+    let mut totals_vec: Vec<(i16, usize)> = totals.into_iter().collect();
+    totals_vec.sort_by(|a, b| b.1.cmp(&a.1));
+
+    let max_count = totals_vec.iter().map(|(_, c)| *c).max().unwrap_or(1).max(1);
+
+    html! {
+        <div class="diagnostics-section">
+            <div class="chart">
+                { for totals_vec.into_iter().map(|(room, count)| {
+                    let label = parse_room(room);
+                    let bar_width_percent = (count as f64 / max_count as f64) * 100.0;
+                    html! {
+                        <div class="bar-item">
+                            <div class="diagnostics-header">
+                                <span class="diagnostics-label">{ label }</span>
+                                <span class="diagnostics-count">{ count }</span>
+                            </div>
+                            <div class="bar-container">
+                                <div class="bar" style={format!("width: {}%;", bar_width_percent)}>
+                                </div>
+                            </div>
+                        </div>
+                    }
+                }) }
+            </div>
+        </div>
+    }
+}
+
+#[component(UserTotal)]
+fn user_total_component(props: &UserTotalProps) -> Html {
+    let name_map: HashMap<i16, (String, String)> = props
+        .users
+        .iter()
+        .map(|u| (u.id, (u.first_name.clone(), u.last_name.clone())))
+        .collect();
+
+    let mut counts: HashMap<i16, usize> = HashMap::new();
+    for t in &props.tickets {
+        *counts.entry(t.user_id).or_insert(0) += 1;
+    }
+
+    let mut totals_vec: Vec<(i16, String, String, usize)> = name_map
+        .into_iter()
+        .map(|(id, (fname, lname))| {
+            let c = counts.get(&id).cloned().unwrap_or(0);
+            (id, fname, lname, c)
+        })
+        .collect();
+
+    totals_vec.sort_by(|a, b| b.3.cmp(&a.3));
+
+    let max_count = totals_vec
+        .iter()
+        .map(|(_, _, _, c)| *c)
+        .max()
+        .unwrap_or(1)
+        .max(1);
+
+    html! {
+        <div class="diagnostics-section">
+            <div class="chart">
+                { for totals_vec.into_iter().map(|(_id, fname, lname, count)| {
+                    let label = format!("{} {}", dequote!(fname), dequote!(lname));
+                    let bar_width_percent = (count as f64 / max_count as f64) * 100.0;
+                    html! {
+                        <div class="bar-item">
+                            <div class="diagnostics-header">
+                                <span class="diagnostics-label">{ label }</span>
+                                <span class="diagnostics-count">{ count }</span>
+                            </div>
+                            <div class="bar-container">
+                                <div class="bar" style={format!("width: {}%;", bar_width_percent)}>
+                                </div>
+                            </div>
+                        </div>
+                    }
+                }) }
+            </div>
+        </div>
+    }
+}
+
+/// A component for displaying how many problems were solved without creating a ticket
+///
+/// # Functionality
+/// Fetches the value for the count from `/api/count` and parses it into a [`CountResponse`]
+///
+/// # Example
+/// ``` rust
+/// html! {
+///     <EasyFixCount/>
+/// }
+/// ```
+#[component(EasyFixCount)]
+fn easy_fix_component() -> Html {
+    let count = use_state(|| 0);
+    let error = use_state(|| None::<String>);
+
+    {
+        let count = count.clone();
+        let error = error.clone();
+
+        use_effect_with((), move |_| {
+            spawn_local(async move {
+                match Request::get("/api/count").send().await {
+                    Ok(resp) if resp.status() == 200 => match resp.json::<CountResponse>().await {
+                        Ok(r) => count.set(r.value),
+                        Err(e) => error.set(Some(format!("parse error: {}", e))),
+                    },
+                    Ok(resp) => error.set(Some(
+                        resp.text()
+                            .await
+                            .unwrap_or_else(|_| format!("status {}", resp.status())),
+                    )),
+                    Err(e) => error.set(Some(format!("Network error: {}", e))),
+                }
+            });
+            || ()
+        });
+    }
+    html! {
+        <div class="open-tickets">
+            <h2 class="left">{ "Probleme ohne Ticket gelößt" }</h2>
+            <h4 class="ticket_count center">{ *count }</h4>
+        </div>
+    }
+}

frontend/src/styles/_mixins.scss

@@ -0,0 +1,12 @@
+@use "variables" as *;
+
+@mixin card {
+  background: $color-container;
+  border-radius: $border-radius;
+  box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+  padding: $spacing-md;
+
+  @media (prefers-color-scheme: dark) {
+    background: $color-container-dark;
+  }
+}

frontend/src/styles/_utilities.scss

@@ -0,0 +1,5 @@
+@use "variables" as *;
+
+.u-hidden { display: none !important; }
+.u-gap-sm { gap: $spacing-sm; }
+.text-muted { color: $color-muted; }

frontend/src/styles/_variables.scss

@@ -0,0 +1,34 @@
+// Color Palette (Reference Style)
+$color-bg: #f0f2f5;
+$color-bg-dark: #121212;
+$color-container: #ffffff;
+$color-container-dark: #333333;
+$color-sidebar: #0f172a;
+$color-primary: #2b79c2;
+$color-primary-hover: #1d5fa0;
+$color-accent: #2b79c2;
+$color-muted: #6b7280;
+$color-text: #111827;
+$color-text-dark: #e2e2e2;
+
+// Status Colors
+$color-status-todo: #ffcccc;
+$color-status-todo-text: #a00;
+$color-status-inprogress: #fff3cd;
+$color-status-inprogress-text: #856404;
+$color-status-done: #d4edda;
+$color-status-done-text: #155724;
+$color-status-archived: #e0e0e0;
+$color-status-archived-text: #666666;
+
+// Action Colors
+$color-logout: #ff4d4d;
+$color-logout-hover: #e60000;
+
+// Spacing
+$spacing-sm: 8px;
+$spacing-md: 16px;
+$spacing-lg: 2rem;
+$border-radius: 0.5rem;
+$border-radius-lg: 10px;
+

frontend/src/styles/components/_alltickets.scss

@@ -0,0 +1,82 @@
+@use "../variables" as *;
+
+.ticket-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+  margin-bottom: $spacing-lg;
+
+  li {
+    border-left: 4px solid;
+    padding: 1rem;
+    margin-bottom: 1rem;
+    border-radius: $border-radius-lg;
+    background: $color-container;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+
+    @media (prefers-color-scheme: dark) {
+      background: $color-container-dark;
+    }
+
+    h3 {
+      margin-top: 0;
+      margin-bottom: $spacing-md;
+      color: $color-primary;
+
+      a {
+        color: $color-primary;
+        text-decoration: none;
+        transition: color 0.2s ease-in-out;
+
+        &:hover {
+          color: $color-primary-hover;
+          text-decoration: underline;
+        }
+      }
+    }
+
+    p {
+      margin: 0.3rem 0;
+    }
+
+    &.To-Do {
+      border-left-color: $color-status-todo-text;
+    }
+
+    &.InProgress {
+      border-left-color: $color-status-inprogress-text;
+    }
+
+    &.Completed {
+      border-left-color: $color-status-done-text;
+    }
+
+    &.Archived {
+      border-left-color: $color-status-archived-text;
+    }
+  }
+}
+
+.ticket-list-actions {
+  display: flex;
+  gap: $spacing-md;
+  flex-wrap: wrap;
+  margin-top: $spacing-lg;
+
+  a {
+    display: inline-block;
+    padding: $spacing-md $spacing-lg;
+    background: $color-primary;
+    color: white;
+    text-decoration: none;
+    border-radius: $border-radius;
+    font-weight: bold;
+    cursor: pointer;
+    transition: background-color 0.2s ease-in-out;
+
+    &:hover {
+      background-color: $color-primary-hover;
+    }
+  }
+}
+

frontend/src/styles/components/_allusers.scss

@@ -0,0 +1,13 @@
+@use "../variables" as *;
+
+.user-list {
+  list-style: none;
+  padding-left: 0;
+  margin: 0;
+
+  li {
+    h3 {
+      margin-top: 0;
+    }
+  }
+}

frontend/src/styles/components/_diagnostics.scss

@@ -0,0 +1,217 @@
+@use "../mixins" as *;
+@use "../variables" as *;
+
+.diagnostics-container {
+  display: flex;
+  flex-direction: column;
+  gap: $spacing-md;
+}
+
+.diagnostics-section {
+  background-color: $color-container;
+  border-radius: $border-radius;
+  padding: $spacing-md;
+  box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+
+  @media (prefers-color-scheme: dark) {
+    background-color: $color-container-dark;
+  }
+
+  h3 {
+    margin: 0;
+    color: $color-primary;
+    font-size: 1.1rem;
+    font-weight: 600;
+  }
+}
+
+.weekday-chart {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  border: 1px solid #e5e7eb;
+  border-radius: $border-radius;
+  background-color: $color-container;
+  margin: 16px 0px;
+
+  @media (prefers-color-scheme: dark) {
+    background-color: $color-container-dark;
+    border-color: #555;
+  }
+}
+
+.weekday-bars {
+  display: flex;
+  gap: 12px;
+  align-items: flex-end;
+  height: 205px;
+  padding: $spacing-md;
+  overflow-x: auto;
+  padding-bottom: 0px;
+}
+
+.weekday-bar {
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  align-items: center;
+  flex: 1;
+  min-width: 60px;
+  height: 100%;
+
+  .bar {
+    width: 100%;
+    background-color: $color-primary;
+    border-radius: 4px 4px 0 0;
+    transition: background-color 0.2s ease;
+
+    &.max {
+      background-color: #10b981;
+    }
+  }
+}
+
+.weekday-labels {
+  display: flex;
+  gap: 12px;
+  padding: $spacing-md;
+  padding-top: 0;
+  overflow-x: auto;
+
+  .label-item {
+    flex: 1;
+    min-width: 60px;
+    text-align: center;
+    white-space: nowrap;
+
+    .day {
+      font-weight: 600;
+      font-size: 12px;
+      color: $color-text;
+      margin-bottom: 2px;
+
+      @media (prefers-color-scheme: dark) {
+        color: $color-text-dark;
+      }
+    }
+
+    .value {
+      font-size: 11px;
+      color: $color-muted;
+    }
+  }
+}
+
+.chart {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: $spacing-md;
+  border: 1px solid #e5e7eb;
+  border-radius: $border-radius;
+  background-color: $color-container;
+  width: 100%;
+
+  @media (prefers-color-scheme: dark) {
+    background-color: $color-container-dark;
+    border-color: #555;
+  }
+}
+
+.bar-item {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+
+  .diagnostics-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+
+    .diagnostics-label {
+      font-weight: 600;
+      font-size: 14px;
+      color: $color-text;
+      min-width: 50px;
+
+      @media (prefers-color-scheme: dark) {
+        color: $color-text-dark;
+      }
+    }
+
+    .diagnostics-count {
+      font-size: 12px;
+      color: $color-muted;
+      font-weight: 500;
+    }
+  }
+
+  .bar-container {
+    width: 100%;
+    height: 24px;
+    background-color: #e5e7eb;
+    border-radius: 4px;
+    overflow: hidden;
+
+    @media (prefers-color-scheme: dark) {
+      background-color: #555;
+    }
+
+    .bar {
+      height: 100%;
+      background-color: $color-primary;
+      transition: width 0.3s ease;
+    }
+  }
+}
+
+.diagnostics-row {
+  display: flex;
+  gap: 24px;              
+  align-items: flex-start;
+  flex-wrap: wrap;        
+}
+
+.diagnostics-column {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  width: 48%;             
+  min-width: 280px;       
+}
+
+.open-tickets{
+  display: flex;
+  align-items: center;
+  position: relative;
+  width: 100%;
+  padding: 0 1rem;
+  box-sizing: border-box;
+  min-height: 60px;
+
+  .left {
+    display: flex;
+    align-items: center;
+    flex-shrink: 0;
+    max-width: 30%;
+    
+    h2 {
+      margin: 0;
+      white-space: nowrap;
+    }
+  }
+  
+  .center {
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+  }
+}
+
+.home {
+  .ticket_count {
+    font-size: xxx-large;
+    height: 115px;
+  }
+}

frontend/src/styles/components/_forms.scss

@@ -0,0 +1,97 @@
+@use "../variables" as *;
+
+.form-container {
+  display: flex;
+  flex-direction: column;
+  gap: $spacing-lg;
+  margin-bottom: $spacing-lg;
+
+  form {
+    display: flex;
+    flex-direction: column;
+    gap: $spacing-md;
+
+    label {
+      display: flex;
+      flex-direction: column;
+      gap: $spacing-sm;
+      font-weight: 500;
+      color: $color-text;
+
+      @media (prefers-color-scheme: dark) {
+        color: $color-text-dark;
+      }
+    }
+
+    input, textarea, select {
+      padding: $spacing-md;
+      border: 1px solid #ccc;
+      border-radius: $border-radius;
+      font-family: Arial, sans-serif;
+      font-size: 1rem;
+
+      @media (prefers-color-scheme: dark) {
+        background-color: #6b6b6b;
+        color: $color-text-dark;
+        border-color: #555;
+      }
+
+      &:focus {
+        outline: none;
+        border-color: $color-primary;
+        box-shadow: 0 0 0 2px rgba($color-primary, 0.2);
+      }
+    }
+
+    textarea {
+      min-height: 120px;
+      resize: vertical;
+    }
+
+    button {
+      align-self: flex-start;
+      padding: $spacing-md $spacing-lg;
+      background-color: $color-primary;
+      color: white;
+      border: none;
+      border-radius: $border-radius;
+      font-size: 1rem;
+      font-weight: bold;
+      cursor: pointer;
+      transition: background-color 0.2s ease-in-out;
+
+      &:hover {
+        background-color: $color-primary-hover;
+      }
+
+      &:active {
+        transform: scale(0.98);
+      }
+    }
+
+    a {
+      display: inline-block;
+      padding: $spacing-md $spacing-lg;
+      background: $color-primary;
+      color: white;
+      text-decoration: none;
+      border-radius: $border-radius;
+      text-align: center;
+      transition: background-color 0.2s ease-in-out;
+      align-self: flex-start;
+
+      &:hover {
+        background-color: $color-primary-hover;
+      }
+    }
+  }
+
+  ul {
+    list-style: none;
+    padding-left: 0;
+
+    li h3 {
+      margin-top: 0;
+    }
+  }
+}

frontend/src/styles/components/_login.scss

@@ -0,0 +1,39 @@
+@use "../variables" as *;
+
+.login-btn {
+  display: inline-block;
+  padding: 12px 400px;
+  background: $color-primary;
+  color: white;
+  border-radius: $border-radius-lg;
+  text-decoration: none;
+  font-weight: bold;
+  font-size: 1rem;
+  cursor: pointer;
+  border: none;
+  transition: all 0.2s ease-in-out;
+  margin-bottom: 15px;
+
+  &:hover {
+    background: $color-primary-hover;
+    transform: scale(1.05);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+  }
+}
+
+.logout-btn {
+  display: inline-block;
+  padding: 10px 20px;
+  background: $color-logout;
+  color: white;
+  border-radius: $border-radius-lg;
+  text-decoration: none;
+  font-weight: bold;
+  transition: 0.2s ease-in-out;
+  margin-bottom: 20px;
+
+  &:hover {
+    background: $color-logout-hover;
+    transform: scale(1.05);
+  }
+}

frontend/src/styles/components/_pages.scss

@@ -0,0 +1,272 @@
+@use "../variables" as *;
+
+.page-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: $spacing-lg;
+  padding-bottom: $spacing-md;
+  border-bottom: 2px solid #e5e7eb;
+
+  @media (prefers-color-scheme: dark) {
+    border-bottom-color: #555;
+  }
+
+  h1 {
+    margin: 0;
+    color: $color-primary;
+    font-size: 1.75rem;
+  }
+}
+
+.page-actions {
+  display: flex;
+  gap: $spacing-md;
+  flex-wrap: wrap;
+
+  a, button {
+    display: inline-block;
+    padding: $spacing-md;
+    background: $color-primary;
+    color: white;
+    text-decoration: none;
+    border: none;
+    border-radius: $border-radius;
+    font-weight: bold;
+    cursor: pointer;
+    transition: background-color 0.2s ease-in-out;
+
+    &:hover {
+      background-color: $color-primary-hover;
+    }
+  }
+}
+
+input[type="checkbox"] {
+  width: fit-content;
+}
+
+.grid-list {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+  gap: $spacing-lg;
+  margin-top: $spacing-lg;
+
+  .grid-item {
+    background: $color-container;
+    border: 1px solid #e5e7eb;
+    border-radius: $border-radius;
+    padding: $spacing-md;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    transition: box-shadow 0.2s ease, transform 0.2s ease;
+
+    @media (prefers-color-scheme: dark) {
+      background: $color-container-dark;
+      border-color: #555;
+    }
+
+    &:hover {
+      box-shadow: 0 0 15px rgba(0, 0, 0, 0.15);
+      transform: translateY(-2px);
+    }
+
+    h3 {
+      color: $color-primary;
+      margin-top: 0;
+      margin-bottom: $spacing-md;
+    }
+
+    p {
+      margin: $spacing-sm 0;
+      color: $color-muted;
+
+      &:last-child {
+        margin-bottom: 0;
+      }
+    }
+
+    .item-actions {
+      display: flex;
+      gap: $spacing-md;
+      margin-top: $spacing-md;
+      flex-wrap: wrap;
+
+      a, button {
+        flex: 1;
+        min-width: 100px;
+        padding: $spacing-md;
+        border: none;
+        border-radius: $border-radius;
+        font-weight: bold;
+        cursor: pointer;
+        text-decoration: none;
+        text-align: center;
+        transition: background-color 0.2s ease-in-out;
+      }
+
+      a.view, button.view {
+        background: $color-primary;
+        color: white;
+
+        &:hover {
+          background-color: $color-primary-hover;
+        }
+      }
+
+      a.edit, button.edit {
+        background: #f59e0b;
+        color: white;
+
+        &:hover {
+          background-color: #d97706;
+        }
+      }
+
+      a.delete, button.delete {
+        background: $color-logout;
+        color: white;
+
+        &:hover {
+          background-color: $color-logout-hover;
+        }
+      }
+    }
+  }
+}
+
+.table-container {
+  overflow-x: auto;
+  margin-top: $spacing-lg;
+  border-radius: $border-radius;
+  box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+
+  @media (prefers-color-scheme: dark) {
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.3);
+  }
+
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    background: $color-container;
+
+    @media (prefers-color-scheme: dark) {
+      background: $color-container-dark;
+    }
+
+    thead {
+      background: $color-primary;
+      color: white;
+
+      th {
+        padding: $spacing-md;
+        text-align: left;
+        font-weight: 600;
+        border-bottom: 2px solid darken($color-primary, 10%);
+      }
+    }
+
+    tbody {
+      tr {
+        border-bottom: 1px solid #e5e7eb;
+        transition: background-color 0.2s ease;
+
+        @media (prefers-color-scheme: dark) {
+          border-bottom-color: #555;
+        }
+
+        &:hover {
+          background-color: #f9fafb;
+
+          @media (prefers-color-scheme: dark) {
+            background-color: #444;
+          }
+        }
+
+        td {
+          padding: $spacing-md;
+          color: $color-text;
+
+          @media (prefers-color-scheme: dark) {
+            color: $color-text-dark;
+          }
+        }
+      }
+    }
+  }
+}
+
+.alert {
+  padding: $spacing-md;
+  border-radius: $border-radius;
+  margin-bottom: $spacing-lg;
+  border-left: 4px solid;
+
+  &.success {
+    background: $color-status-done;
+    color: $color-status-done-text;
+    border-left-color: $color-status-done-text;
+  }
+
+  &.error {
+    background: $color-status-todo;
+    color: $color-status-todo-text;
+    border-left-color: $color-status-todo-text;
+  }
+
+  &.warning {
+    background: $color-status-inprogress;
+    color: $color-status-inprogress-text;
+    border-left-color: $color-status-inprogress-text;
+  }
+
+  &.info {
+    background: #dbeafe;
+    color: #1e40af;
+    border-left-color: #1e40af;
+
+    @media (prefers-color-scheme: dark) {
+      background: #1e3a8a;
+      color: #93c5fd;
+      border-left-color: #93c5fd;
+    }
+  }
+}
+
+.loading-spinner {
+  display: inline-block;
+  width: 20px;
+  height: 20px;
+  border: 3px solid #e5e7eb;
+  border-top-color: $color-primary;
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+
+  @keyframes spin {
+    to { transform: rotate(360deg); }
+  }
+}
+
+.empty-state {
+  text-align: center;
+  padding: $spacing-lg;
+  color: $color-muted;
+
+  p {
+    font-size: 1.1rem;
+    margin-bottom: $spacing-md;
+  }
+
+  a {
+    display: inline-block;
+    padding: $spacing-md $spacing-lg;
+    background: $color-primary;
+    color: white;
+    text-decoration: none;
+    border-radius: $border-radius;
+    transition: background-color 0.2s ease-in-out;
+
+    &:hover {
+      background-color: $color-primary-hover;
+    }
+  }
+}

frontend/src/styles/components/_setup.scss

@@ -0,0 +1,120 @@
+@use "../variables" as *;
+
+.setup-container {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 100vh;
+  background: $color-bg;
+  padding: $spacing-lg;
+
+  @media (prefers-color-scheme: dark) {
+    background: $color-bg-dark;
+  }
+}
+
+.setup-box {
+  width: 100%;
+  max-width: 400px;
+  background: $color-container;
+  padding: $spacing-lg;
+  border-radius: 1rem;
+  box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
+
+  @media (prefers-color-scheme: dark) {
+    background: $color-container-dark;
+  }
+
+  h1 {
+    color: $color-primary;
+    text-align: center;
+    margin-top: 0;
+    margin-bottom: $spacing-md;
+  }
+
+  p {
+    text-align: center;
+    color: $color-muted;
+    margin-bottom: $spacing-lg;
+  }
+}
+
+.setup-form {
+  display: flex;
+  flex-direction: column;
+  gap: $spacing-md;
+
+  .form-group {
+    display: flex;
+    flex-direction: column;
+    gap: $spacing-sm;
+
+    label {
+      font-weight: 500;
+      color: $color-text;
+
+      @media (prefers-color-scheme: dark) {
+        color: $color-text-dark;
+      }
+    }
+  }
+
+  input {
+    padding: $spacing-md;
+    border: 1px solid #ccc;
+    border-radius: $border-radius;
+    font-family: Arial, sans-serif;
+    font-size: 1rem;
+
+    @media (prefers-color-scheme: dark) {
+      background-color: #6b6b6b;
+      color: $color-text-dark;
+      border-color: #555;
+    }
+
+    &:focus {
+      outline: none;
+      border-color: $color-primary;
+      box-shadow: 0 0 0 2px rgba($color-primary, 0.2);
+    }
+  }
+
+  button {
+    padding: $spacing-md;
+    background-color: $color-primary;
+    color: white;
+    border: none;
+    border-radius: $border-radius;
+    font-size: 1rem;
+    font-weight: bold;
+    cursor: pointer;
+    transition: background-color 0.2s ease-in-out;
+    margin-top: $spacing-md;
+
+    &:hover {
+      background-color: $color-primary-hover;
+    }
+
+    &:active {
+      transform: scale(0.98);
+    }
+  }
+}
+
+.success-message {
+  background: $color-status-done;
+  color: $color-status-done-text;
+  padding: $spacing-md;
+  border-radius: $border-radius;
+  margin-bottom: $spacing-md;
+  border-left: 4px solid $color-status-done-text;
+}
+
+.error-message {
+  background: $color-status-todo;
+  color: $color-status-todo-text;
+  padding: $spacing-md;
+  border-radius: $border-radius;
+  margin-bottom: $spacing-md;
+  border-left: 4px solid $color-status-todo-text;
+}

frontend/src/styles/components/_sidebar.scss

@@ -0,0 +1,54 @@
+@use "../variables" as *;
+@use "../mixins" as *;
+
+.sidebar {
+  width: 260px;
+  background: $color-sidebar;
+  color: #fff;
+  min-height: 100%;
+  padding: $spacing-md;
+  display: flex;
+  flex-direction: column;
+
+  ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: $spacing-sm; flex: 1; }
+
+  a, .menu-toggle {
+    color: #fff;
+    text-decoration: none;
+    display: block;
+    padding: 8px 12px;
+    border-radius: $border-radius;
+    transition: background 0.2s ease-in-out;
+    &:hover { background: rgba(255,255,255,0.1); }
+  }
+
+  .menu-toggle { background: transparent; border: none; text-align: left; width: 100%; cursor: pointer; }
+
+  .submenu {
+    margin-left: 8px;
+    background: rgba(255,255,255,0.05);
+    border-radius: $border-radius;
+    padding: 6px;
+    li { padding: 4px 0; }
+  }
+
+  .logout-item {
+    margin-top: auto;
+    border-top: 1px solid rgba(255,255,255,0.1);
+    padding-top: $spacing-sm;
+  }
+
+  .logout-button {
+    background: rgba(255, 255, 255, 0.1);
+    color: #fff;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    padding: 8px 12px;
+    border-radius: 4px;
+    width: 100%;
+    cursor: pointer;
+    text-align: left;
+  }
+
+  &.user { width: 220px; background: darken($color-sidebar, 6%); }
+}
+

frontend/src/styles/components/_tickets.scss

@@ -0,0 +1,80 @@
+@use "../mixins" as *;
+@use "../variables" as *;
+
+.ticket {
+  border: 1px solid #ccc;
+  padding: 1rem;
+  margin-bottom: 1rem;
+  border-radius: $border-radius-lg;
+  background: $color-container;
+  box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+
+  @media (prefers-color-scheme: dark) {
+    background: $color-container-dark;
+  }
+
+  h3 {
+    margin-top: 0;
+    color: $color-primary;
+  }
+
+  p {
+    margin: 0.3rem 0;
+  }
+}
+
+.ticket-card {
+  @include card();
+  border-left: 4px solid $color-primary;
+  display: flex;
+  flex-direction: column;
+  gap: $spacing-sm;
+  .meta { color: $color-muted; font-size: 0.9rem; }
+  .title { font-weight: 600; }
+}
+
+.status {
+  display: inline-block;
+  padding: 4px 10px;
+  border-radius: 8px;
+  font-size: 0.8rem;
+  font-weight: bold;
+  margin-top: 8px;
+
+  &.To-Do { 
+    background: $color-status-todo; 
+    color: $color-status-todo-text; 
+  }
+
+  &.InProgress { 
+    background: $color-status-inprogress; 
+    color: $color-status-inprogress-text; 
+  }
+
+  &.Done { 
+    background: $color-status-done; 
+    color: $color-status-done-text; 
+  }
+
+  &.Completed { 
+    background: $color-status-done; 
+    color: $color-status-done-text; 
+  }
+
+  &.Archived { 
+    background: $color-status-archived; 
+    color: $color-status-archived-text; 
+  }
+}
+
+.ticket_count {
+  text-align: center;
+  align-content: center;
+  color: #005f00;
+  border: 2px solid #848484;
+  border-radius: 10px;
+  height: 50px;
+  width: 250px;
+  margin: 0;
+  font-size: xx-large;
+}

frontend/src/styles/main.scss

@@ -0,0 +1,175 @@
+@use "variables";
+@use "mixins";
+@use "utilities";
+@use "components/sidebar";
+@use "components/tickets";
+@use "components/alltickets";
+@use "components/allusers";
+@use "components/forms";
+@use "components/login";
+@use "components/diagnostics";
+@use "components/pages";
+@use "components/setup";
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  background: variables.$color-bg;
+  font-family: Arial, sans-serif;
+  color: variables.$color-text;
+  margin: 0;
+  padding: 0;
+
+  @media (prefers-color-scheme: dark) {
+    background: variables.$color-bg-dark;
+    color: variables.$color-text-dark;
+  }
+}
+
+input, textarea, select {
+  width: 100%;
+  padding: variables.$spacing-md;
+  font-size: 1rem;
+  border-radius: variables.$border-radius;
+  border: 1px solid #ccc;
+  box-sizing: border-box;
+  margin-bottom: 15px;
+  font-family: Arial, sans-serif;
+
+  @media (prefers-color-scheme: dark) {
+    background-color: #6b6b6b;
+    color: variables.$color-text-dark;
+    border-color: #555;
+  }
+}
+
+button {
+  padding: variables.$spacing-md;
+  font-size: 1rem;
+  border-radius: variables.$border-radius;
+  background-color: variables.$color-primary;
+  color: white;
+  border: none;
+  cursor: pointer;
+  margin-bottom: 15px;
+  transition: background-color 0.2s ease-in-out;
+  font-family: Arial, sans-serif;
+  font-weight: bold;
+
+  &:hover {
+    background-color: variables.$color-primary-hover;
+  }
+}
+
+form {
+  display: flex;
+  flex-direction: column;
+  gap: variables.$spacing-md;
+
+  label {
+    display: flex;
+    flex-direction: column;
+    gap: variables.$spacing-sm;
+    font-weight: 500;
+  }
+
+  a {
+    display: inline-block;
+    padding: variables.$spacing-md;
+    background: variables.$color-primary;
+    color: white;
+    text-decoration: none;
+    border-radius: variables.$border-radius;
+    text-align: center;
+    transition: background-color 0.2s ease-in-out;
+
+    &:hover {
+      background-color: variables.$color-primary-hover;
+    }
+  }
+}
+
+.container {
+  max-width: 900px;
+  margin: auto;
+  background: variables.$color-container;
+  padding: variables.$spacing-lg;
+  border-radius: 1rem;
+  box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
+
+  @media (prefers-color-scheme: dark) {
+    background: variables.$color-container-dark;
+  }
+}
+
+.header-with-image {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 20px;
+}
+
+.header-with-image img {
+  height: 60px;
+}
+
+.admin { display: flex; }
+
+.layout {
+  display: flex;
+  min-height: 100vh;
+  margin: 0;
+  padding: 0;
+}
+
+.sidebar {
+  width: 260px;
+  flex-shrink: 0;
+  position: fixed;
+  left: 0;
+  top: 0;
+  height: 100vh;
+  overflow-y: auto;
+}
+
+.content {
+  flex: 1;
+  min-width: 0;
+  margin-left: 260px;
+  padding: variables.$spacing-lg;
+  
+  > :first-child {
+    max-width: 900px;
+    margin: 0 auto;
+    background: variables.$color-container;
+    padding: variables.$spacing-lg;
+    border-radius: 1rem;
+    box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
+
+    @media (prefers-color-scheme: dark) {
+      background: variables.$color-container-dark;
+    }
+  }
+
+  h1, h2, h3 {
+    color: variables.$color-primary;
+    margin-top: 0;
+  }
+}
+
+@media (max-width: 768px) {
+  .sidebar { 
+    position: fixed; 
+    left: -260px; 
+    transition: left .3s ease-in-out;
+    z-index: 1000;
+  }
+  .sidebar.open { 
+    left: 0; 
+  }
+  .content { 
+    margin-left: 0;
+  }
+}

src/lib.rs

@@ -0,0 +1 @@
+#![doc = include_str!("../README.md")]