Docs update

dequote and the count components are still missing

README.md

@@ -6,54 +6,3 @@ A ticket system with backend and frontend components.
 
 - **[Backend](../backend/index.html)** - The server-side API and business logic
 - **[Frontend](../frontend/index.html)** - The client-side user interface
-
-## Usage
-### Prerequisite
-> [!IMPORTANT]
-> Before compiling the programm you have to install the rust toolchain. 
-> For a guide to do this, visit: <https://rust-lang.org/tools/install/>
-
-A instance of a postgresql has to be accessible to the backend. Place the connection details in a .env file into the variable `DATABASE_URL`
-To setup the tables you either can create them manually by following the sheme specified in `backend/migrations` or apply them with sqlx
-To install sqlx run `cargo install sqlx` and then in the `backend` directory run `sqlx migrate run` to create the tables
-
-### Environment
-The .env file has to be in the root directory of the project or in the same directory as the executable
-
-Keys:
-`DATABASE_URL`: Specifying the url and connection details for the database
-`TOKEN_SECRET`: The JWT token secret, can theoretically be anything but is more secure when generated with a tool, e.g: <https://jwtsecrets.com/>
-`ORIGIN`: The origin of the frontend, used for CORS rules
-`BACKEND_PORT`: The port which the backend should use to run on
-
-### Backend
-The backend can either be run via `cargo run --release` or `cargo build --release` using the correct target architecture, e.g. 'x86_64-unknown-linux-gnu', 
-the executable will be placed in the `target/release` directory and can then be run via any method
-
-### Frontend
-The HTML code for the frontend can be generated by using `trunk build`. The resulting files will end up in the `frontend/dist` directory and can be served over any webserver supporting wasm
-> [!NOTE]
-> To install trunk run `cargo install trunk`
-
-> [!IMPORTANT]
-> Requests from the frontend to /api/* have to be proxied to the Backend
-> Example with nginx and frontend running at localhost:8000 and backend at localhost:9000 :
-> ```nginx
-> location /api/ {
->   proxy_pass http://localhost:9000/api;
-> }
-> ```
-
-
-
-
-## Usage of AI
-
-Github Copilot CLI was used with the model Claude Haiku 4.5 to generate most of the documentation:
-
-### Prompt 
-Generate comments for cargo doc describing the indivilual components and create links to relevant structs, functions etc.
-
-### Output
-The comments with `///` or `//!`
-I've gone over most of it and modified it to my needs and opinions

backend/src/cookie/jwt.rs

@@ -6,8 +6,8 @@ use crate::models::Claims;
 
 /// Error response for JWT token operations.
 ///
-/// Returned when token encoding or decoding fails via `encode_token` or `decode_token`.
+/// Returned when token encoding or decoding fails. Used in error responses
-/// Used in error responses for invalid or expired [`Claims`] tokens.
+/// for invalid or expired tokens.
 ///
 /// # Fields
 /// - `status`: HTTP status text (e.g., "error")
@@ -22,7 +22,7 @@ pub struct Error {
 ///
 /// 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. The resulting token is a serialized [`Claims`].
+/// using the given encoding key.
 ///
 /// # Arguments
 /// - `header`: The JWT header, specifying the algorithm (e.g., HS256).
@@ -30,7 +30,7 @@ pub struct Error {
 /// - `key`: The `EncodingKey` used to sign the JWT.
 ///
 /// # Returns
-/// A `String` representing the encoded JWT containing [`Claims`].
+/// A `String` representing the encoded JWT.
 ///
 /// # Panics
 /// Panics if the token encoding fails for any reason (e.g., invalid key).
@@ -50,16 +50,15 @@ pub fn encode_token(header: &Header, id: String, key: &EncodingKey) -> String {
 ///
 /// 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. Returns the extracted [`Claims`]
+/// and "not before" (`validate_nbf`) claims during validation.
-/// on success.
 ///
 /// # Arguments
 /// - `token`: The JWT string to decode.
 /// - `key`: The `DecodingKey` used to verify the JWT's signature.
 ///
 /// # Returns
-/// - `Ok(Claims)`: If the token is successfully decoded and verified, returns the extracted [`Claims`].
+/// - `200 OK`: If the token is successfully decoded and verified, returns the extracted `Claims`.
-/// - `Err((StatusCode, Json<Error>))`: If the token is invalid, expired, or cannot be decoded,
+/// - `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 mut validation = jsonwebtoken::Validation::new(jsonwebtoken::Algorithm::HS256);

backend/src/cookie/validation.rs

@@ -17,23 +17,22 @@ use crate::{AppState, cookie::jwt::decode_token, handlers::auth::filter_user, mo
 /// 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 using [`decode_token`](`crate::cookie::jwt::decode_token`)).
+/// the `Authorization: Bearer` header), decodes and validates it. If valid, it fetches
-/// If valid, it fetches the corresponding [`User`] from the database and inserts a
+/// the corresponding user from the database and inserts a `FilteredUser` into the
-/// [`FilteredUser`](crate::models::FilteredUser)
+/// request extensions for subsequent handlers to use.
-/// (converted via [`filter_user`](`crate::handlers::auth::filter_user`)) 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.
-/// - `State(data)`: Application state containing `AppState` for database access and `token_secret`.
+/// - `request`: The incoming HTTP request, which will have user data injected into its extensions.
-/// - `mut request`: The incoming HTTP request, which will have user data injected into its extensions.
 /// - `next`: The next middleware or handler in the chain.
 ///
 /// # Returns
-/// - `Ok(impl IntoResponse)`: If validation succeeds, the request proceeds to the next handler.
+/// - `200 OK`: If validation succeeds, the request proceeds to the next handler.
-/// - `Err((StatusCode, Json<serde_json::Value>))`: An error response if validation fails.
+/// - `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>>,
@@ -111,24 +110,22 @@ pub async fn validate_token(
 
 /// 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,
+/// This middleware first performs all checks of `validate_token`: extracting, decoding,
-/// and validating the JWT via [`decode_token`](`crate::cookie::jwt::decode_token`), and fetching the associated [`User`] from the database.
+/// 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`. Returns a [`FilteredUser`](crate::models::FilteredUser)
+/// Additionally, it verifies that the fetched user has `is_admin` set to `true`.
-/// (converted via [`filter_user`](`crate::handlers::auth::filter_user`)) in the request extensions if both authentication and admin status are valid.
 ///
 /// 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.
-/// - `State(data)`: Application state containing `AppState`.
+/// - `request`: The incoming HTTP request, which will have admin user data injected.
-/// - `mut request`: The incoming HTTP request, which will have admin user data injected.
 /// - `next`: The next middleware or handler in the chain.
 ///
 /// # Returns
-/// - `Ok(impl IntoResponse)`: If validation and admin check succeed, the request proceeds.
+/// - `200 OK`: If validation and admin check succeed, the request proceeds.
-/// - `Err((StatusCode, Json<serde_json::Value>))`: An error response if validation fails
+/// - `401 UNAUTHORIZED`: An error response if validation fails or the user is not an admin.
-///   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>>,

backend/src/env.rs

@@ -1,13 +1,12 @@
 /// Environment configuration for the application.
 ///
 /// Loads required configuration from environment variables at startup.
-/// All variables must be present or the application will panic during [`Env::load`].
+/// All variables must be present or the application will panic.
-/// Used by [`AppState`](crate::AppState) for configuring JWT signing and CORS.
 ///
 /// # Fields
-/// - `db_url`: PostgreSQL database connection URL
+/// - `db_url`: PostgreSQL database connection URL.
-/// - `token_secret`: Secret key used to sign and verify [`Claims`](crate::models::Claims) in JWT tokens
+/// - `token_secret`: Secret key used to sign and verify JWT tokens.
-/// - `origin`: Frontend origin URL for CORS policy configuration
+/// - `origin`: Frontend origin URL for CORS policy.
 ///
 /// # Required Environment Variables
 /// - `DATABASE_URL`: PostgreSQL connection string (e.g., `postgresql://user:pass@localhost/dbname`)
@@ -21,38 +20,26 @@ pub struct Env {
     pub token_secret: String,
     /// Frontend origin URL for CORS policy
     pub origin: String,
-    /// Backend port number
-    pub backend_port: String,
 }
 
 impl Env {
     /// Loads environment configuration from system environment variables.
     ///
-    /// Reads `DATABASE_URL`, `TOKEN_SECRET`, and `ORIGIN` from the environment and returns
+    /// Panics if any required variable is missing.
-    /// a configured [`Env`] instance. Used during server initialization in the `main` function.
-    ///
-    /// # Panics
-    /// If any required variable is missing (DATABASE_URL, TOKEN_SECRET, or ORIGIN).
     ///
     /// # Example
     /// ```ignore
     /// let env = Env::load();
     /// // Environment must have DATABASE_URL, TOKEN_SECRET, and ORIGIN set
-    /// let app_state = AppState {
-    ///     db: pool,
-    ///     env,
-    /// };
     /// ```
     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");
         let origin = std::env::var("ORIGIN").expect("ORIGIN must be set");
-        let backend_port = std::env::var("BACKEND_PORT").expect("BACKEND_PORT must be set");
         Env {
             db_url,
             token_secret,
             origin,
-            backend_port,
         }
     }
 }

backend/src/handlers/auth.rs

@@ -22,12 +22,11 @@ use crate::{
 
 /// Registers a new user in the system.
 ///
-/// Creates a new [`User`] account with the provided [`UserCreateScheme`] credentials.
+/// Creates a new user account with the provided credentials. The password is hashed using Argon2
-/// The password is hashed using Argon2 before being stored. Only administrators can create new users.
+/// before being stored. Only administrators can create new users.
 ///
 /// # Arguments
-/// - `State(data)`: Application state containing [`AppState`] for database access
+/// - `request`: Json with [UserCreateScheme] as it's format
-/// - `request`: [`UserCreateScheme`] containing user details including first/last name, username, admin flag, and password
 ///
 /// # Returns
 /// - `200 OK` on successful user creation
@@ -35,7 +34,12 @@ use crate::{
 /// - `500 Internal Server Error` if database insertion fails
 ///
 /// # Password Hashing
-/// Uses Argon2 with a cryptographically secure random salt.
+/// 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>,
@@ -102,23 +106,27 @@ 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 and encodes a [`Claims`](crate::models::Claims) token via [`encode_token`](`crate::cookie::jwt::encode_token`) and sets it as an HTTP-only cookie.
+/// On successful authentication, generates a JWT token and sets it as an HTTP-only cookie.
 /// The token is valid for 1 hour.
 ///
 /// # Arguments
-/// - `State(data)`: Application state containing [`AppState`] for database access
+/// - `request`: Login credentials in Json format using the [LoginScheme]
-/// - `request`: [`LoginScheme`] containing login credentials (username, password)
 ///
 /// # Returns
-/// - `200 OK` with JSON containing token and filtered [`FilteredUser`] info
+/// - `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 with stored [`User`] hash
+/// - Password verification uses Argon2:
-/// - JWT token includes user ID and expiration timestamp via [`Claims`](crate::models::Claims) encoded by [`encode_token`](`crate::cookie::jwt::encode_token`)
+///   ```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
@@ -187,7 +195,7 @@ pub async fn login(
 ///
 /// 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. The cookie no longer contains a valid [`Claims`](crate::models::Claims) token.
+/// session invalidation.
 ///
 /// # Returns
 /// Always returns `200 OK` with success message and an expired cookie header
@@ -219,11 +227,11 @@ pub async fn logout() -> Result<impl IntoResponse, (StatusCode, Json<serde_json:
 
 /// Retrieves the currently authenticated user's information.
 ///
-/// Uses the [`FilteredUser`] data embedded in the JWT token (via middleware).
+/// 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 [`FilteredUser`] data (excluding password)
+/// - `200 OK` with the [FilteredUser] in Json format
 /// - Automatically returns `401 Unauthorized` if not authenticated (middleware)
 ///
 /// # Example Response
@@ -256,12 +264,11 @@ pub async fn get_current_user(
 
 /// Deletes a user account from the system.
 ///
-/// Only admins can delete users (enforced by middleware). The [`User`] account and all associated data is removed.
+/// 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
-/// - `Path(id)`: [`User`] ID to delete, extracted from URL path
+/// - `id`: User ID to delete
-/// - `State(data)`: Application state containing [`AppState`] for database access
 ///
 /// # Returns
 /// - `204 No Content` on successful deletion
@@ -295,14 +302,11 @@ pub async fn delete_user(
 
 /// Retrieves all users in the system.
 ///
-/// Only admins can call this endpoint (enforced by middleware). Returns all [`User`] records converted to [`FilteredUser`]
+/// Only admins can call this endpoint. Returns all users sorted alphabetically by last name.
-/// and sorted alphabetically by last name. Password hashes are not included in the response.
+/// Password hashes are not included in the response.
-///
-/// # Arguments
-/// - `State(data)`: Application state containing [`AppState`] for database access
 ///
 /// # Returns
-/// - `200 OK` with array of [`FilteredUser`] objects
+/// - `200 OK` with array of [FilteredUser] objects
 /// - `500 Internal Server Error` if database query fails
 ///
 /// # Example Response
@@ -348,15 +352,11 @@ pub async fn get_users(
 
 /// Retrieves a single user's details by their ID.
 ///
-/// This endpoint allows fetching a specific [`User`]'s information. It returns a [`FilteredUser`]
-/// object (converted via [`filter_user`]), ensuring sensitive data like password hashes are not exposed.
-///
 /// # Arguments
-/// - `Path(id)`: The ID of the [`User`] to retrieve, extracted from the URL path.
+/// - `id`: The ID of the user to retrieve, extracted from the URL path.
-/// - `State(data)`: Application state containing [`AppState`] for database access.
 ///
 /// # Returns
-/// - `200 OK` with a [`FilteredUser`] JSON object if the user is found.
+/// - `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.
 ///
@@ -392,24 +392,18 @@ pub async fn get_user_by_id(
 
 /// Updates an existing user's information.
 ///
-/// This endpoint allows administrators to modify a [`User`]'s `first_name`, `last_name`,
-/// `username`, `is_admin` status, and optionally their password. If `new_pwd` in the
-/// request body is an empty string, the user's password remains unchanged.
-///
 /// # Arguments
-/// - `Path(id)`: The ID of the [`User`] to update, extracted from the URL path.
+/// - `id`: The ID of the user to update, extracted from the URL path.
-/// - `State(data)`: Application state containing [`AppState`] for database access.
+/// - `body`: [UserUpdateScheme] containing the fields to update.
-/// - `Json(body)`: [`UserUpdateScheme`] containing the fields to update.
 ///
 /// # Returns
-/// - `200 OK` with the [`FilteredUser`] object of the updated user (converted via [`filter_user`]).
+/// - `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 requires admin privileges (enforced by middleware via
+/// - This endpoint typically requires admin privileges (enforced by middleware).
-/// [`validate_admin`](crate::cookie::validation::validate_admin)).
 pub async fn update_user(
     Path(id): Path<i32>,
     State(data): State<Arc<AppState>>,
@@ -467,14 +461,8 @@ pub async fn update_user(
 
 /// Checks if any administrator user exists in the system.
 ///
-/// This endpoint is used during initialization to determine if the setup page should be displayed.
-/// It counts all [`User`] records with `is_admin = true` in the database.
-///
-/// # Arguments
-/// - `State(data)`: Application state containing [`AppState`] for database access
-///
 /// # Returns
-/// - `200 OK` with JSON: `{"has_admin": bool}` - Whether at least one admin exists
+/// - `200 OK` On successful database query
 /// - `500 Internal Server Error` if database query fails
 ///
 /// # Example Response
@@ -501,24 +489,28 @@ pub async fn check_admin_exists(
 
 /// 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
+/// This function handles the one-time setup of the first admin user. It checks that no admin exists
-/// before allowing creation via database count. This endpoint is only functional when the system has no administrators.
+/// 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
-/// - `State(data)`: Application state containing [`AppState`] for database access
+/// - `request`: [UserCreateScheme] as a Json value
-/// - `request`: [`UserCreateScheme`] containing user creation details (first_name, last_name, username, password)
 ///
 /// # Returns
 /// - `200 OK` with success message if admin account created
 /// - `400 Bad Request` if:
-///   - Admin already exists (checked via admin count)
+///   - 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.
+/// 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>,
@@ -583,18 +575,17 @@ pub async fn setup_initial_admin(
     }
 }
 
-/// Converts a [`User`] with sensitive data into a [`FilteredUser`] safe for API responses.
+/// 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
+/// returning user data to clients. Always use this helper instead of directly
-/// serializing [`User`] objects.
+/// serializing User objects.
-/// Used by all authentication endpoints to ensure passwords are never exposed.
 ///
 /// # Arguments
-/// - `user`: Reference to the internal [`User`] struct containing password hash
+/// - `user`: Reference to the internal [User] struct containing password hash
 ///
 /// # Returns
-/// [`FilteredUser`] with only safe-to-share information:
+/// [FilteredUser] with only safe-to-share information:
 /// - `id`: User ID
 /// - `first_name`, `last_name`: User name
 /// - `username`: Login username
@@ -607,7 +598,7 @@ pub async fn setup_initial_admin(
 /// # Example
 /// ```ignore
 /// let user = get_user_from_db(1).await?;
-/// let safe_user = filter_user(&user);  // Convert User to FilteredUser
+/// let safe_user = filter_user(&user);
 /// // safe_user can be safely serialized and sent to client
 /// ```
 pub fn filter_user(user: &User) -> FilteredUser {

backend/src/handlers/ticket.rs

@@ -16,14 +16,12 @@ use crate::{
 
 /// Creates a new support ticket.
 ///
-/// Associates the ticket with the authenticated [`FilteredUser`] and sets the current timestamp.
+/// Associates the ticket with the authenticated user and sets the current timestamp.
-/// Converts the [`TicketCreateScheme`] request into a database record.
 /// Tickets are automatically created with "open" status.
 ///
 /// # Arguments
-/// - `Extension(user)`: Authenticated [`FilteredUser`] (extracted from JWT token via middleware)
+/// - `user`: Authenticated user (extracted from JWT token)
-/// - `State(data)`: Application state containing [`AppState`] for database access
+/// - `body`: Json with the [TicketCreateScheme] as it's format
-/// - `Json(body)`: [`TicketCreateScheme`] containing ticket details (category, subject, description, room)
 ///
 /// # Returns
 /// - `200 OK` on successful creation
@@ -62,11 +60,10 @@ pub async fn create_ticket(
 
 /// Deletes a ticket by ID.
 ///
-/// Only admins can delete tickets (enforced by middleware). Removes the [`TicketResponse`] and associated data from the database.
+/// Only admins can delete tickets. Marks the ticket as deleted or removes from database.
 ///
 /// # Arguments
-/// - `Path(id)`: Ticket ID to delete, extracted from URL path
+/// - `id`: Ticket ID to delete
-/// - `State(data)`: Application state containing [`AppState`] for database access
 ///
 /// # Returns
 /// - `204 No Content` on successful deletion
@@ -98,20 +95,16 @@ pub async fn delete_ticket(
     Ok(StatusCode::NO_CONTENT)
 }
 
-/// Retrieves all non-archived tickets.
+/// Retrieves all tickets.
 ///
-/// Returns a list of all active [`TicketResponse`] objects with user information denormalized for easier rendering.
+/// Returns a list of all tickets with user information denormalized for easier rendering.
-/// Tickets are ordered by creation date (newest first). Joins with [`User`](crate::models::User) table to include creator information.
+/// Tickets are ordered by creation date (newest first).
-///
-/// # Arguments
-/// - `State(data)`: Application state containing [`AppState`] for database access
 ///
 /// # Filtering
-/// - Excludes tickets with status "Archived"
+/// - Uses LEFT JOIN to include creator information
-/// - Uses LEFT JOIN to include creator information from [`User`](crate::models::User)
 ///
 /// # Returns
-/// - `200 OK` with array of [`TicketResponse`] objects
+/// - `200 OK` with array of [TicketResponse] objects
 /// - `500 Internal Server Error` if database query fails
 ///
 /// # Example Response
@@ -175,14 +168,12 @@ pub async fn get_tickets(
 /// Retrieves a specific ticket by ID.
 ///
 /// Includes full ticket details and denormalized user information (creator name).
-/// Returns a [`TicketResponse`] with all metadata by joining with [`User`](crate::models::User) table.
 ///
 /// # Arguments
-/// - `Path(id)`: Ticket ID to retrieve, extracted from URL path
+/// - `id`: Ticket ID to retrieve
-/// - `State(data)`: Application state containing [`AppState`] for database access
 ///
 /// # Returns
-/// - `200 OK` with [`TicketResponse`] object
+/// - `200 OK` with [TicketResponse] object
 /// - `404 Not Found` if ticket doesn't exist
 /// - `500 Internal Server Error` if database error occurs
 ///
@@ -250,16 +241,15 @@ pub async fn get_ticket_by_id(
 
 /// Updates a ticket's status.
 ///
-/// Only admins can update ticket status (enforced by middleware). Applies [`TicketUpdateScheme`] to modify the [`TicketResponse`].
+/// Only admins can update ticket status. This is typically used to transition tickets
-/// This is typically used to transition tickets through their lifecycle (open → in_progress → resolved → archived).
+/// through their lifecycle (open → in_progress → resolved → archived).
 ///
 /// # Arguments
-/// - `Path(id)`: Ticket ID to update, extracted from URL path
+/// - `id`: Ticket ID to update
-/// - `State(data)`: Application state containing [`AppState`] for database access
+/// - `body`: Update payload as a Json array with [TicketUpdateScheme] as it's format
-/// - `Json(body)`: [`TicketUpdateScheme`] update payload containing new status
 ///
 /// # Returns
-/// - `200 OK` with updated [`TicketResponse`]
+/// - `200 OK` with updated [TicketResponse]
 /// - `500 Internal Server Error` if ticket not found or database error
 ///
 /// # Typical Status Flow

backend/src/main.rs

@@ -9,28 +9,61 @@ 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::http::{
+use axum::{
-    HeaderValue, Method,
+    Json,
-    header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE},
+    http::{
+        HeaderValue, Method, StatusCode,
+        header::{ACCEPT, AUTHORIZATION, CONTENT_TYPE},
+    },
 };
 use dotenv::dotenv;
 use router::create_router;
+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 and cloned into each route
+/// This is wrapped in Arc for thread-safe sharing across async tasks.
-/// via `with_state`.
 ///
 /// # Fields
-/// - `db`: PostgreSQL connection pool for database access (via `sqlx::PgPool`)
+/// - `db`: PostgreSQL connection pool for database access
-/// - `env`: [`Env`] configuration loaded from environment variables
+/// - `env`: Configuration loaded from environment variables
 pub struct AppState {
     db: PgPool,
     env: Env,
@@ -40,19 +73,15 @@ pub struct AppState {
 ///
 /// Initializes the server by:
 /// 1. Loading environment variables from `.env` file
-/// 2. Establishing database connection pool to PostgreSQL
+/// 2. Establishing database connection pool
 /// 3. Configuring CORS policy for cross-origin requests
-/// 4. Creating the router with [`create_router`] containing all endpoints
+/// 4. Starting HTTP server on port 8001
-/// 5. 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 [`Env`]
+/// - CORS origin configured from environment
-///
-/// # State Setup
-/// Creates shared [`AppState`] wrapped in `Arc` and passes to all routes
 ///
 /// # Panics
 /// - If environment loading fails
@@ -90,7 +119,6 @@ async fn main() {
     .layer(cors);
 
     // Start listening for incoming connections
-    let uri = format!("0.0.0.0:{}", env.backend_port);
+    let listener = tokio::net::TcpListener::bind("0.0.0.0:8001").await.unwrap();
-    let listener = tokio::net::TcpListener::bind(&uri).await.unwrap();
     let _ = axum::serve(listener, app).await;
 }

backend/src/models.rs

@@ -3,7 +3,6 @@ use serde::{Deserialize, Serialize};
 /// API response for a ticket with user information.
 ///
 /// Returned by ticket endpoints. Includes denormalized user data for easier frontend rendering.
-/// Created via [`TicketCreateScheme`].
 ///
 /// # Fields
 /// - `id`: Unique ticket identifier
@@ -13,7 +12,7 @@ use serde::{Deserialize, Serialize};
 /// - `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 (references [`User`])
+/// - `user_id`: ID of the user who created the ticket
 /// - `user_first_name`, `user_last_name`: User's name (denormalized for convenience)
 ///
 /// # Example
@@ -48,7 +47,7 @@ pub struct TicketResponse {
 /// 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.
+/// This should NEVER be sent directly to clients - always use `FilteredUser` instead.
 ///
 /// # Fields
 /// - `id`: Unique user identifier
@@ -59,7 +58,7 @@ pub struct TicketResponse {
 ///
 /// # Security Note
 /// The `pwd` field contains the password hash and should never be included in API responses.
-/// Use [`filter_user()`](`crate::handlers::auth::filter_user`) to convert to [`FilteredUser`] for responses.
+/// Use `filter_user()` to convert to `FilteredUser` for responses.
 #[derive(Deserialize, Serialize, PartialEq, Debug, Clone, sqlx::FromRow)]
 pub struct User {
     pub id: i16,
@@ -73,7 +72,7 @@ pub struct User {
 /// 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. Converted to [`TicketResponse`] for the response.
+/// authenticated user and sets the creation timestamp.
 ///
 /// # Fields
 /// - `category`: Ticket category/type
@@ -90,7 +89,7 @@ pub struct TicketCreateScheme {
 
 /// Payload for updating a ticket.
 ///
-/// Sent to `PATCH /api/tickets/{id}`. Allows updating the ticket [`TicketResponse::status`].
+/// Sent to `PATCH /api/tickets/{id}`. Currently only allows status updates.
 /// Only admins can update tickets.
 ///
 /// # Fields
@@ -103,10 +102,10 @@ pub struct TicketUpdateScheme {
 /// Payload for updating user information.
 ///
 /// Sent to `PATCH /api/users/{id}`. Allows updating profile and admin status.
-/// Only admins can update [`User`] records. Empty password field means no password change.
+/// Only admins can update users. Empty password field means no password change.
 ///
 /// # Fields
-/// - `id`: [`User`] ID to update
+/// - `id`: User ID to update
 /// - `first_name`, `last_name`: Updated user name
 /// - `username`: Updated login username
 /// - `make_admin`: New admin privilege status
@@ -124,7 +123,7 @@ pub struct UserUpdateScheme {
 /// 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. Converted to [`User`] for storage.
+/// The password is hashed server-side before storage using Argon2.
 ///
 /// # Fields
 /// - `first_name`: User's first name
@@ -156,7 +155,7 @@ pub struct LoginScheme {
 
 /// User information sent to clients, excluding password hashes.
 ///
-/// This is the safe version of [`User`] data that gets returned in API responses.
+/// 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)]
@@ -171,10 +170,10 @@ pub struct FilteredUser {
 /// JWT token claims embedded in the session token.
 ///
 /// Contains user identification and token validity information.
-/// Generated during login via `encode_token` and verified via `decode_token`.
+/// Generated during login and verified by middleware on protected routes.
 ///
 /// # Fields
-/// - `sub`: Subject - the user ID as a string (references [`User`])
+/// - `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)
 ///

backend/src/router.rs

@@ -8,42 +8,43 @@ use axum::{
 use crate::{
     AppState,
     cookie::validation::{validate_admin, validate_token},
+    get_count,
     handlers::{
         auth::{
-            check_admin_exists, create_user, delete_user, get_current_user, get_user_by_id, get_users, login, logout,
+            check_admin_exists, create_user, delete_user, get_current_user, get_user_by_id,
-            setup_initial_admin, update_user,
+            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. Uses [`AppState`]
+/// The router is organized in layers for proper middleware application:
-/// for shared application context across all routes.
 ///
 /// ## Route Layers (from most to least restricted):
 ///
 /// ### Admin-Only Routes (requires admin privilege + valid token)
-/// - `GET /api/tickets/{id}` - Get specific ticket details (via `get_ticket_by_id`)
+/// - `GET /api/tickets/{id}` - Get specific ticket details
-/// - `DELETE /api/tickets/{id}` - Delete a ticket (via `delete_ticket`)
+/// - `DELETE /api/tickets/{id}` - Delete a ticket
-/// - `PATCH /api/tickets/{id}` - Update ticket status (via `edit_ticket`)
+/// - `PATCH /api/tickets/{id}` - Update ticket status
-/// - `POST /api/register` - Create a new user (via `create_user`)
+/// - `POST /api/register` - Create a new user
-/// - `GET /api/users` - List all users (via `get_users`)
+/// - `GET /api/users` - List all users
-/// - `GET /api/users/{id}` - Get user details (via `get_user_by_id`)
+/// - `GET /api/users/{id}` - Get user details
-/// - `DELETE /api/users/{id}` - Delete a user (via `delete_user`)
+/// - `DELETE /api/users/{id}` - Delete a user
-/// - `PATCH /api/users/{id}` - Update user details (via `update_user`)
+/// - `PATCH /api/users/{id}` - Update user details
 ///
 /// ### Protected Routes (requires valid token)
-/// - `GET /api/tickets` - List all tickets (via `get_tickets`)
+/// - `GET /api/tickets` - List all tickets
-/// - `POST /api/tickets/create` - Create a new ticket (via `create_ticket`)
+/// - `POST /api/tickets/create` - Create a new ticket
-/// - `GET /api/logout` - Logout user (via `logout`)
+/// - `GET /api/logout` - Logout user
-/// - `GET /api/users/current` - Get current authenticated user (via `get_current_user`)
+/// - `GET /api/users/current` - Get current authenticated user
 ///
 /// ### Public Routes (no authentication required)
-/// - `POST /api/login` - User login (via `login`)
+/// - `POST /api/login` - User login
-/// - `GET /api/check-admin` - Check if admin exists (via `check_admin_exists`)
+/// - `GET /api/check-admin` - Check if admin exists (for setup detection)
-/// - `POST /api/setup-admin` - Create initial admin account (via `setup_initial_admin`)
+/// - `POST /api/setup-admin` - Create initial admin account (only if no admin exists)
 ///
 /// # Middleware Stack
 /// - Admin routes have `validate_admin` middleware
@@ -74,6 +75,7 @@ pub fn create_router(state: Arc<AppState>) -> Router {
         .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,

frontend/Trunk.toml

@@ -1,6 +1,6 @@
 [serve]
 # The address to serve on LAN.
-addresses = ["127.0.0.1"] #,"10.150.9.116"]
+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/src/auth.rs

@@ -33,14 +33,14 @@ pub struct ProtectedRouteProps {
 
 /// A component that protects routes by enforcing authentication and optional administrator privileges.
 ///
-/// This component uses the backend's validation middleware by fetching the current user's authentication
+/// This component fetches the current user's authentication and admin status from the
-/// and admin status from the `/api/users/current` endpoint (which requires a valid JWT token).
+/// `/api/users/current` endpoint upon mounting. Based on the `AuthState` and the
-/// Based on the [`AuthState`] and the `admin_page` property, it either renders its children or redirects the user.
+/// `admin_page` property, it either renders its children or redirects the user.
 ///
 /// # Behavior
-/// - **Initial Load**: Displays "Loading..." while checking authentication status via the backend.
+/// - **Initial Load**: Displays "Loading..." while checking authentication status.
 /// - **Not Authenticated**: Redirects to the login page (`crate::Route::Login`).
-/// - **Authenticated** (valid JWT token from backend):
+/// - **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

frontend/src/lib.rs

@@ -10,9 +10,7 @@ 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. Each route is protected
+/// enabling navigation within the single-page application.
-/// by [`ProtectedRoute`] middleware where appropriate to enforce authentication and authorization.
-/// See [`switch`] for the routing logic.
 #[derive(Clone, PartialEq, Routable)]
 enum Route {
     /// The application's home page.
@@ -67,10 +65,10 @@ pub struct SidebarShellProps {
 /// 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. Integrates with [`crate::pages::sidebar::Sidebar`] for navigation.
+/// is always present for navigation.
 ///
 /// # Components
-/// - [`crate::pages::sidebar::Sidebar`]: The navigation sidebar component.
+/// - [`sidebar::Sidebar`]: The navigation sidebar component.
 /// - Main content area: Renders the `children` passed to this component.
 ///
 /// # Example
@@ -93,7 +91,7 @@ fn sidebar_shell(props: &SidebarShellProps) -> Html {
     }
 }
 
-/// Props for the AdminCheckWrapper component.
+/// Props for the [AdminCheckWrapper] component.
 #[derive(Properties, PartialEq)]
 pub struct AdminCheckWrapperProps {
     pub children: Children,
@@ -103,11 +101,11 @@ pub struct AdminCheckWrapperProps {
 ///
 /// 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
-/// backend's `/api/check-admin` endpoint (via `crate::handlers::auth::check_admin_exists`) to determine system state.
+/// `/api/check-admin` endpoint to determine system state.
 ///
 /// # Behavior
-/// - **Loading**: Displays "Loading..." while checking admin status from the backend
+/// - **Loading**: Displays "Loading..." while checking admin status
-/// - **No Admin**: Automatically redirects to [`Route::Setup`] page for initialization
+/// - **No Admin**: Automatically redirects to `/setup` page to initialize
 /// - **Admin Exists**: Renders the wrapped children (e.g., login page)
 ///
 /// # Example Usage
@@ -117,9 +115,19 @@ pub struct AdminCheckWrapperProps {
 /// </AdminCheckWrapper>
 /// ```
 ///
-/// # Backend Integration
+/// # Implementation Detail
-/// The check queries the backend's `/api/check-admin` endpoint which returns `{"has_admin": bool}`.
+/// The check happens in `use_effect_with` on component mount:
-/// This allows the frontend to determine if initial admin setup is required.
+/// ```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>);
@@ -158,24 +166,18 @@ fn admin_check_wrapper(props: &AdminCheckWrapperProps) -> Html {
 
 /// The main routing logic for the application.
 ///
-/// This function takes a [`Route`] enum variant and returns the corresponding HTML
+/// 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 and authentication flow.
+/// navigation.
 ///
-/// Most routes are wrapped in [`ProtectedRoute`] to enforce authentication
+/// Many routes are wrapped in a [`ProtectedRoute`] to enforce authentication
-/// and authorization based on the `admin_page` flag, and in [`SidebarShell`] to maintain consistent layout.
+/// and authorization, and in a [`SidebarShell`] to maintain consistent layout.
-/// Login and Setup routes use [`AdminCheckWrapper`] instead to handle pre-authentication states.
 ///
 /// # Arguments
 /// - `route`: The [`Route`] enum variant representing the current URL path.
 ///
 /// # Returns
 /// An `Html` component that should be rendered for the given route.
-///
-/// # Route Protection
-/// - **Admin-required routes** (`admin_page={true}`): Require both authentication and admin privileges
-/// - **Public routes** (`admin_page={false}`): Require only authentication
-/// - **Pre-auth routes** (`AdminCheckWrapper`): Used before admin creation or login
 fn switch(route: Route) -> Html {
     match route {
         Route::Home => html! {
@@ -258,15 +260,11 @@ fn switch(route: Route) -> Html {
 ///
 /// 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`] matched by the `switch` function.
+/// is rendered based on the current route.
-///
-/// Uses [`switch`] as the routing dispatcher to handle all route-specific rendering,
-/// which applies appropriate middleware like [`ProtectedRoute`] and [`AdminCheckWrapper`].
 ///
 /// # Structure
 /// - `BrowserRouter`: Enables client-side routing.
-/// - `Switch`: Renders components based on the matched [`Route`].
+/// - `Switch`: Renders components based on the matched [Route].
-/// - `switch` function: Determines which component to render for each route.
 #[component(App)]
 pub fn app() -> Html {
     html! {

frontend/src/pages/basic_pages.rs

@@ -3,30 +3,8 @@ 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]
-/// Removes surrounding double quotes from a string.
-///
-/// This macro takes an expression that evaluates to a string and returns a new `String`
-/// with any leading or trailing double quotes removed. It's useful for cleaning up
-/// string data that might be inadvertently wrapped in quotes, such as JSON string values.
-///
-/// # Arguments
-///
-/// * `$str`: An expression that can be converted into a string slice (`&str`).
-///
-/// # Examples
-///
-/// ```rust
-/// use your_crate::dequote; // Assuming `dequote` is re-exported or in scope
-///
-/// let quoted_string = "\"hello world\"";
-/// let dequoted_string = dequote!(quoted_string);
-/// assert_eq!(dequoted_string, "hello world");
-///
-/// let already_clean = "no quotes";
-/// let dequoted_clean = dequote!(already_clean);
-/// assert_eq!(dequoted_clean, "no quotes");
-/// ```
 macro_rules! dequote {
     ($str:expr) => {
         $str.trim_matches('"').to_string()
@@ -120,10 +98,6 @@ pub fn not_found_component() -> Html {
 
 /// A component displayed when a user attempts to access a page for which they do not have sufficient permissions.
 ///
-/// It informs the user about the access restriction and provides instructions to contact
-/// a specific person ("Herr Winter") if they believe this is an error.
-/// It also includes a link to return to the home page.
-///
 /// # Example
 /// ```rust
 /// html! {

frontend/src/pages/setup.rs

@@ -29,7 +29,7 @@ pub struct AdminSetupScheme {
 /// 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`]).
+///   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.

frontend/src/pages/sidebar.rs

@@ -7,11 +7,6 @@ use wasm_bindgen_futures::spawn_local;
 use yew::prelude::*;
 use yew_router::prelude::*;
 
-/// The key used to store and retrieve the sidebar's expansion state in `LocalStorage`.
-///
-/// This constant ensures consistency when accessing the stored state across different
-/// parts of the application. The value associated with this key in `LocalStorage`
-/// will be a serialized [`SidebarExpandState`] object.
 const STORAGE_KEY: &str = "sidebar_state";
 
 /// Represents the expansion state of collapsible menus within the sidebar.

frontend/src/pages/ticket.rs

@@ -169,6 +169,31 @@ pub fn submit_ticket_component() -> Html {
 
     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();

frontend/src/pages/user.rs

@@ -102,14 +102,6 @@ pub struct UserProps {
     pub id: i16,
 }
 
-/// Represents an error response from the API.
-///
-/// This struct is used to deserialize error messages received from the backend API.
-/// It typically contains a human-readable message and an internal status code.
-///
-/// # Fields
-/// - `message`: A `String` containing a description of the error.
-/// - `_status`: An internal status code or message, often ignored in frontend display.
 #[derive(Deserialize, Debug)]
 struct ApiError {
     message: String,

frontend/src/pages/utilities.rs

@@ -9,6 +9,12 @@ 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
@@ -17,6 +23,7 @@ use crate::pages::ticket::{ActiveUser, Ticket};
 /// # 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>,
@@ -26,13 +33,12 @@ struct TicketPartial {
 
 /// A partial representation of a user, containing only the fields necessary for statistical analysis.
 ///
-/// This struct is used to efficiently retrieve and process user data for diagnostics
+/// This struct is used to retrieve and process user data for diagnostics
-/// without fetching the full user details.
 ///
 /// # Fields
-/// - `id`: The unique identifier of the user.
+/// - `id`: The users id
-/// - `first_name`: The first name of the user.
+/// - `first_name`: The users first name
-/// - `last_name`: The last name of the user.
+/// - `last_name`: The users last name
 #[derive(Debug, Deserialize, Clone, PartialEq)]
 struct UserPartial {
     id: i16,
@@ -46,20 +52,12 @@ struct UserPartial {
 /// for calculating and visualizing ticket distribution per room.
 ///
 /// # Fields
-/// - `tickets`: A vector of [`TicketPartial`] containing ticket data relevant for room totals.
+/// - `tickets`: A vector of `TicketPartial` containing ticket data relevant for room totals.
 #[derive(Properties, PartialEq)]
 struct RoomTotalsProps {
     tickets: Vec<TicketPartial>,
 }
 
-/// Properties for components that display user-wise ticket totals.
-///
-/// This struct passes a list of partial user data and partial ticket data to a component
-/// responsible for calculating and visualizing ticket distribution per user.
-///
-/// # Fields
-/// - `users`: A vector of [`UserPartial`] containing user data relevant for user totals.
-/// - `tickets`: A vector of [`TicketPartial`] containing ticket data relevant for user totals.
 #[derive(Properties, PartialEq)]
 struct UserTotalProps {
     users: Vec<UserPartial>,
@@ -96,7 +94,7 @@ fn weekday_index(dt: &DateTime<Utc>) -> usize {
 /// the total count of tickets submitted on that day.
 ///
 /// # Arguments
-/// - `tickets`: A slice of [`TicketPartial`] items to count.
+/// - `tickets`: A slice of `TicketPartial` items to count.
 ///
 /// # Returns
 /// An array `[usize; 7]` with ticket counts for each weekday.
@@ -110,12 +108,12 @@ fn count_by_weekday(tickets: &[TicketPartial]) -> [usize; 7] {
 
 /// 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`]
+/// 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.
+/// - `partials`: A slice of `TicketPartial` items defining the date range.
 ///
 /// # Returns
 /// An array `[usize; 7]` where each element represents the number of times a
@@ -164,8 +162,7 @@ fn day_counts(partials: &[TicketPartial]) -> [usize; 7] {
 
 /// Converts a numerical room representation back into a human-readable string format.
 ///
-/// This function is the inverse of the room parsing logic in
+/// This function is the inverse of the room parsing logic in `SubmitTicket` component.
-/// [`SubmitTicket`](`crate::pages::ticket::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.
 ///
@@ -204,6 +201,7 @@ pub fn diagnostics_component() -> Html {
     html! {
         <div>
             <TicketCount/>
+            <EasyFixCount/>
             <SubmitStats/>
         </div>
     }
@@ -336,12 +334,12 @@ pub fn ticket_count_component() -> Html {
 ///
 /// # State
 /// Uses `use_state` hooks to manage:
-/// - `tickets`: A vector of [`TicketPartial`] for statistical analysis.
+/// - `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`.
+/// - 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.
@@ -495,7 +493,7 @@ pub fn submit_stats_component() -> Html {
 /// - **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
+/// - **Room Formatting**: Uses the `parse_room` function to display room numbers
 ///   in a human-readable format.
 ///
 /// # Example
@@ -540,30 +538,6 @@ fn room_total_component(props: &RoomTotalsProps) -> Html {
     }
 }
 
-/// A component that displays the total number of tickets per user.
-///
-/// This component takes lists of [`UserPartial`] and [`TicketPartial`] items to calculate
-/// and display the total number of tickets submitted by each user.
-/// The results are presented in a sorted list with a bar chart visualization.
-///
-/// # Props
-/// - `users`: A `Vec<UserPartial>` containing partial user data.
-/// - `tickets`: A `Vec<TicketPartial>` containing partial ticket data for analysis.
-///
-/// # Functionality
-/// - **Maps User Names**: Creates a map from user IDs to their first and last names for display.
-/// - **Calculates Totals**: Aggregates ticket counts for each user.
-/// - **Sorts Results**: Displays users sorted by their 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 user, relative to the user with the maximum tickets.
-/// - **Name Formatting**: Uses the [`dequote!`] macro to clean up user names before display.
-///
-/// # Example
-/// ```rust
-/// html! {
-///     <UserTotal users={my_user_partials} tickets={my_ticket_partials} />
-/// }
-/// ```
 #[component(UserTotal)]
 fn user_total_component(props: &UserTotalProps) -> Html {
     let name_map: HashMap<i16, (String, String)> = props
@@ -617,3 +591,49 @@ fn user_total_component(props: &UserTotalProps) -> Html {
         </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>
+    }
+}