Replace edit button with a Material icon, adjust styles, and add MatIconModule to component imports.

This reverts commit e3fd0944df.

backend/build.gradle.kts

@@ -27,6 +27,7 @@ dependencies {
     implementation(project(":open_api"))
     implementation(project(":database"))
     implementation(project(":frontend"))
+    implementation(project(":discord"))
     annotationProcessor("org.projectlombok:lombok")
     implementation("com.mysql:mysql-connector-j:8.0.32")
     implementation("org.mybatis:mybatis:3.5.13")
@@ -36,6 +37,12 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-security")
     implementation("org.springframework.security:spring-security-oauth2-resource-server")
     implementation("org.springframework.security:spring-security-oauth2-jose")
+    implementation("org.springframework.boot:spring-boot-starter-mail:3.1.5")
+    implementation("org.springframework.boot:spring-boot-starter-thymeleaf")
+
+    //Open API
+    implementation("io.swagger.core.v3:swagger-annotations:2.2.37")
+    implementation("io.swagger.core.v3:swagger-models:2.2.37")
 
     //AOP
     implementation("org.aspectj:aspectjrt:1.9.19")

backend/src/main/java/com/alttd/altitudeweb/AltitudeWebApplication.java

@@ -5,7 +5,7 @@ import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 
-@SpringBootApplication
+@SpringBootApplication(scanBasePackages = {"com.alttd.altitudeweb"})
 @EnableAspectJAutoProxy
 public class AltitudeWebApplication {
 

backend/src/main/java/com/alttd/altitudeweb/config/SecurityConfig.java

@@ -9,22 +9,31 @@ import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
 import com.nimbusds.jose.jwk.source.JWKSource;
 import com.nimbusds.jose.proc.SecurityContext;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpMethod;
 import org.springframework.security.config.Customizer;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
 import org.springframework.security.oauth2.jwt.JwtDecoder;
 import org.springframework.security.oauth2.jwt.JwtEncoder;
 import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
 import org.springframework.security.oauth2.jwt.NimbusJwtEncoder;
+import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
 import org.springframework.security.web.SecurityFilterChain;
 
 import java.security.KeyPair;
 import java.security.interfaces.RSAPrivateKey;
 import java.security.interfaces.RSAPublicKey;
+import java.util.*;
+import java.util.stream.Collectors;
 
+@Slf4j
 @Configuration
 @EnableWebSecurity
 @RequiredArgsConstructor
@@ -38,15 +47,21 @@ public class SecurityConfig {
         return http
                 .authorizeHttpRequests(
                         auth -> auth
-                                .requestMatchers("/form/**").hasAuthority(PermissionClaimDto.USER.getValue())
-                                .requestMatchers("/head_mod/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
-                                .requestMatchers("/particles/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
-                                .requestMatchers("/files/save/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
+                                .requestMatchers(HttpMethod.OPTIONS, "/**").permitAll()
+                                .requestMatchers("/api/form/**").authenticated()
+                                .requestMatchers("/api/login/getUsername").authenticated()
+                                .requestMatchers("/api/mail/**").authenticated()
+                                .requestMatchers("/api/head_mod/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
+                                .requestMatchers("/api/particles/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
+                                .requestMatchers("/api/files/save/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
+                                .requestMatchers("/api/history/admin/**").hasAuthority(PermissionClaimDto.HEAD_MOD.getValue())
+                                .requestMatchers("/api/login/userLogin/**").permitAll()
                                 .anyRequest().permitAll()
                 )
+                .csrf(AbstractHttpConfigurer::disable)
                 .oauth2ResourceServer(
                         oauth2 -> oauth2
-                                .jwt(Customizer.withDefaults())
+                                .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter()))
                                 .authenticationEntryPoint(securityAuthFailureHandler)
                                 .accessDeniedHandler(securityAuthFailureHandler)
                 )
@@ -57,7 +72,8 @@ public class SecurityConfig {
                 )
                 .sessionManagement(
                         session -> session
-                                .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+                                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+                )
                 .build();
     }
 
@@ -76,4 +92,46 @@ public class SecurityConfig {
         KeyPair keyPair = keyPairService.getJwtSigningKeyPair();
         return NimbusJwtDecoder.withPublicKey((RSAPublicKey) keyPair.getPublic()).build();
     }
+
+
+
+    @Bean
+    public JwtAuthenticationConverter jwtAuthenticationConverter() {
+        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
+        converter.setJwtGrantedAuthoritiesConverter(jwt -> {
+            Map<String, Object> claims = jwt.getClaims();
+
+            Object authoritiesClaim = claims.get("authorities");
+            if (authoritiesClaim instanceof List<?> authorities) {
+                Collection<GrantedAuthority> authorityList = authorities.stream()
+                        .map(Object::toString)
+                        .map(SimpleGrantedAuthority::new)
+                        .collect(Collectors.toList());
+                log.debug("Authorities found in authorities: {}", authorityList);
+                return authorityList;
+            }
+
+            Object scopeClaim = claims.get("scope");
+            if (scopeClaim instanceof String scopeString) {
+                Collection<GrantedAuthority> authorityList = Arrays.stream(scopeString.split(" "))
+                        .map(scope -> new SimpleGrantedAuthority("SCOPE_" + scope))
+                        .collect(Collectors.toList());
+                log.debug("Authorities found in authorities scope string: {}", authorityList);
+                return authorityList;
+            }
+
+            if (scopeClaim instanceof List<?> scopeList) {
+                Collection<GrantedAuthority> authorityList = scopeList.stream()
+                        .map(Object::toString)
+                        .map(scope -> new SimpleGrantedAuthority("SCOPE_" + scope))
+                        .collect(Collectors.toList());
+                log.debug("Authorities found in authorities scope list: {}", authorityList);
+                return authorityList;
+            }
+
+            log.debug("No granted authorities found");
+            return Collections.emptyList();
+        });
+        return converter;
+    }
 }

backend/src/main/java/com/alttd/altitudeweb/config/WebConfig.java

@@ -1,21 +1,24 @@
 package com.alttd.altitudeweb.config;
 
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.core.io.Resource;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 import org.springframework.web.servlet.resource.PathResourceResolver;
 
 import java.io.IOException;
 
-@Configuration
+@Slf4j @Configuration
 public class WebConfig implements WebMvcConfigurer {
 
     @Override
     public void addResourceHandlers(ResourceHandlerRegistry registry) {
         registry.addResourceHandler("/**")
-                .addResourceLocations("classpath:/static/")
+                .addResourceLocations("classpath:/static/browser")
                 .resourceChain(true)
                 .addResolver(new PathResourceResolver() {
                     @Override
@@ -23,11 +26,23 @@ public class WebConfig implements WebMvcConfigurer {
                         Resource requestedResource = location.createRelative(resourcePath);
 
                         if (requestedResource.exists() && requestedResource.isReadable()) {
+                            log.debug("Serving resource {} from {}", resourcePath, location);
                             return requestedResource;
                         }
 
-                        return new ClassPathResource("/static/index.html");
+                        log.debug("Resource {} not found in {}, serving index.html", resourcePath, location);
+
+                        return new ClassPathResource("/static/browser/index.html");
                     }
                 });
     }
+
+    @Controller
+    public static class HomeController {
+        @GetMapping("/")
+        public String index() {
+            return "forward:/index.html";
+        }
+    }
+
 }

backend/src/main/java/com/alttd/altitudeweb/controllers/CorsConfig.java

@@ -18,7 +18,7 @@ public class CorsConfig implements WebMvcConfigurer {
         log.info("Registering CORS mappings for {}", String.join(", ", allowedOrigins));
         registry.addMapping("/**")
                 .allowedOrigins(allowedOrigins)
-                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
+                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH")
                 .allowedHeaders("*")
                 .allowCredentials(true);
     }

backend/src/main/java/com/alttd/altitudeweb/controllers/application/AppealController.java

@@ -1,36 +0,0 @@
-package com.alttd.altitudeweb.controllers.application;
-
-import com.alttd.altitudeweb.api.AppealsApi;
-import com.alttd.altitudeweb.services.limits.RateLimit;
-import com.alttd.altitudeweb.model.AppealResponseDto;
-import com.alttd.altitudeweb.model.DiscordAppealDto;
-import com.alttd.altitudeweb.model.MinecraftAppealDto;
-import com.alttd.altitudeweb.model.UpdateMailDto;
-import org.springframework.http.HttpStatusCode;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.server.ResponseStatusException;
-
-import java.util.concurrent.TimeUnit;
-
-@RestController
-@RateLimit(limit = 30, timeValue = 1, timeUnit = TimeUnit.HOURS)
-public class AppealController implements AppealsApi {
-
-    @RateLimit(limit = 3, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "discordAppeal")
-    @Override
-    public ResponseEntity<MinecraftAppealDto> submitDiscordAppeal(DiscordAppealDto discordAppealDto) {
-        throw new ResponseStatusException(HttpStatusCode.valueOf(501), "Discord appeals are not yet supported");
-    }
-
-    @RateLimit(limit = 3, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "minecraftAppeal")
-    @Override
-    public ResponseEntity<AppealResponseDto> submitMinecraftAppeal(MinecraftAppealDto minecraftAppealDto) {
-        throw new ResponseStatusException(HttpStatusCode.valueOf(501), "Minecraft appeals are not yet supported");
-    }
-
-    @Override
-    public ResponseEntity<AppealResponseDto> updateMail(UpdateMailDto updateMailDto) {
-        throw new ResponseStatusException(HttpStatusCode.valueOf(501), "Updating mail is not yet supported");
-    }
-}

backend/src/main/java/com/alttd/altitudeweb/controllers/data_from_auth/AuthenticatedUuid.java

@@ -0,0 +1,42 @@
+package com.alttd.altitudeweb.controllers.data_from_auth;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.oauth2.jwt.Jwt;
+import org.springframework.stereotype.Service;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.UUID;
+
+@Service
+public class AuthenticatedUuid {
+    @Value("${UNSECURED:#{false}}")
+    private boolean unsecured;
+
+    /**
+     * Extracts and validates the authenticated user's UUID from the JWT token.
+     *
+     * @return The UUID of the authenticated user
+     * @throws ResponseStatusException with 401 status if authentication is invalid
+     */
+    public UUID getAuthenticatedUserUuid() {
+        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+
+        if (authentication == null || !(authentication.getPrincipal() instanceof Jwt jwt)) {
+            if (unsecured) {
+                return UUID.fromString("55e46bc3-2a29-4c53-850f-dbd944dc5c5f");
+            }
+            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED, "Authentication required");
+        }
+
+        String stringUuid = jwt.getSubject();
+
+        try {
+            return UUID.fromString(stringUuid);
+        } catch (IllegalArgumentException e) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Invalid UUID format");
+        }
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/controllers/forms/AppealController.java

@@ -0,0 +1,138 @@
+package com.alttd.altitudeweb.controllers.forms;
+
+import com.alttd.altitudeweb.api.AppealsApi;
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.litebans.HistoryRecord;
+import com.alttd.altitudeweb.database.litebans.HistoryType;
+import com.alttd.altitudeweb.database.litebans.IdHistoryMapper;
+import com.alttd.altitudeweb.database.web_db.forms.Appeal;
+import com.alttd.altitudeweb.database.web_db.forms.AppealMapper;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerification;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerificationMapper;
+import com.alttd.altitudeweb.mappers.AppealDataMapper;
+import com.alttd.altitudeweb.model.DiscordAppealDto;
+import com.alttd.altitudeweb.model.FormResponseDto;
+import com.alttd.altitudeweb.model.MinecraftAppealDto;
+import com.alttd.altitudeweb.model.UpdateMailDto;
+import com.alttd.altitudeweb.services.limits.RateLimit;
+import com.alttd.altitudeweb.services.mail.AppealMail;
+import com.alttd.altitudeweb.setup.Connection;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatusCode;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@RestController
+@AllArgsConstructor
+@RateLimit(limit = 30, timeValue = 1, timeUnit = TimeUnit.HOURS)
+public class AppealController implements AppealsApi {
+
+    private final AppealDataMapper mapper;
+    private final AppealMail appealMail;
+    private final com.alttd.altitudeweb.services.discord.AppealDiscord appealDiscord;
+
+    @RateLimit(limit = 3, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "discordAppeal")
+    @Override
+    public ResponseEntity<FormResponseDto> submitDiscordAppeal(DiscordAppealDto discordAppealDto) {
+        throw new ResponseStatusException(HttpStatusCode.valueOf(501), "Discord appeals are not yet supported");
+    }
+
+    @RateLimit(limit = 3, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "minecraftAppeal")
+    @Override
+    public ResponseEntity<FormResponseDto> submitMinecraftAppeal(MinecraftAppealDto minecraftAppealDto) {
+        boolean success = true;
+        CompletableFuture<Appeal> appealCompletableFuture = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.DEFAULT)
+                  .runQuery(sqlSession -> {
+                      log.debug("Loading history by id");
+                      try {
+                          Appeal appeal = mapper.minecraftAppealDtoToAppeal(minecraftAppealDto);
+                          sqlSession.getMapper(AppealMapper.class).createAppeal(appeal);
+                          appealCompletableFuture.complete(appeal);
+                      } catch (Exception e) {
+                          log.error("Failed to load history count", e);
+                          appealCompletableFuture.completeExceptionally(e);
+                      }
+                  });
+        Appeal appeal = appealCompletableFuture.join();
+        HistoryRecord history = getHistory(appeal.historyType(), appeal.historyId());
+        if (history == null) {
+            throw new ResponseStatusException(HttpStatusCode.valueOf(404), "History not found");
+        }
+        // Send to Discord channels
+        try {
+            appealDiscord.sendAppealToDiscord(appeal, history);
+        } catch (Exception e) {
+            log.error("Failed to send appeal {} to Discord", appeal.id(), e);
+            success = false;
+        }
+
+        appealMail.sendAppealNotification(appeal, history);
+
+        CompletableFuture<Optional<EmailVerification>> emailVerificationCompletableFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sqlSession -> {
+                    log.debug("Retrieving mail by uuid and address");
+
+                    EmailVerification verifiedMail = sqlSession.getMapper(EmailVerificationMapper.class)
+                                                                 .findByUserAndEmail(appeal.uuid(), appeal.email().toLowerCase());
+                    emailVerificationCompletableFuture.complete(Optional.ofNullable(verifiedMail));
+                });
+        Optional<EmailVerification> optionalEmailVerification = emailVerificationCompletableFuture.join();
+
+        if (optionalEmailVerification.isEmpty()) {
+            return ResponseEntity.badRequest().build();
+        }
+        EmailVerification emailVerification = optionalEmailVerification.get();
+        if (!emailVerification.verified()) {
+            return ResponseEntity.badRequest().build();
+        }
+        if (!success) {
+            return ResponseEntity.internalServerError().build();
+        }
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sqlSession -> {
+                    log.debug("Marking appeal {} as sent", appeal.id());
+                    sqlSession.getMapper(AppealMapper.class)
+                            .markAppealAsSent(appeal.id());
+                });
+        FormResponseDto appealResponseDto = new FormResponseDto(
+                appeal.id().toString(),
+                "Your appeal has been submitted. You will be notified when it has been reviewed.",
+                true);
+        return ResponseEntity.ok().body(appealResponseDto);
+    }
+
+    @Override
+    public ResponseEntity<FormResponseDto> updateMail(UpdateMailDto updateMailDto) {
+        //TODO move to its own endpoint
+        throw new ResponseStatusException(HttpStatusCode.valueOf(501), "Updating mail is not yet supported");
+    }
+
+    private HistoryRecord getHistory(String type, int id) {
+        HistoryType historyTypeEnum = HistoryType.getHistoryType(type);
+        CompletableFuture<HistoryRecord> historyRecordCompletableFuture = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.LITE_BANS)
+                  .runQuery(sqlSession -> {
+                      log.debug("Loading history by id");
+                      try {
+                          HistoryRecord punishment = sqlSession.getMapper(IdHistoryMapper.class)
+                                                               .getRecentHistory(historyTypeEnum, id);
+                          historyRecordCompletableFuture.complete(punishment);
+                      } catch (Exception e) {
+                          log.error("Failed to load history count", e);
+                          historyRecordCompletableFuture.completeExceptionally(e);
+                      }
+                  });
+        return historyRecordCompletableFuture.join();
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/controllers/forms/ApplicationController.java

@@ -0,0 +1,155 @@
+package com.alttd.altitudeweb.controllers.forms;
+
+import com.alttd.altitudeweb.api.ApplicationsApi;
+import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.luckperms.UUIDUsernameMapper;
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplication;
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplicationMapper;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerification;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerificationMapper;
+import com.alttd.altitudeweb.mappers.StaffApplicationDataMapper;
+import com.alttd.altitudeweb.model.FormResponseDto;
+import com.alttd.altitudeweb.model.StaffApplicationDto;
+import com.alttd.altitudeweb.services.discord.StaffApplicationDiscord;
+import com.alttd.altitudeweb.services.limits.RateLimit;
+import com.alttd.altitudeweb.services.mail.StaffApplicationMail;
+import com.alttd.altitudeweb.setup.Connection;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@RestController
+@AllArgsConstructor
+@RateLimit(limit = 30, timeValue = 1, timeUnit = TimeUnit.HOURS)
+public class ApplicationController implements ApplicationsApi {
+
+    private final AuthenticatedUuid authenticatedUuid;
+    private final StaffApplicationDataMapper staffApplicationDataMapper;
+    private final StaffApplicationMail staffApplicationMail;
+    private final StaffApplicationDiscord staffApplicationDiscord;
+
+    private final Instant open = Instant.parse("2025-10-18T00:00:00Z");
+    private final Instant close = Instant.parse("2025-10-26T00:00:00Z");
+
+    @Override
+    public ResponseEntity<Boolean> getStaffApplicationsIsOpen() {
+        return ResponseEntity.ok(isOpen());
+    }
+
+    private boolean isOpen() {
+        Instant now = Instant.now();
+        return !now.isBefore(open) && !now.isAfter(close);
+    }
+
+    @Override
+    public ResponseEntity<FormResponseDto> submitStaffApplication(StaffApplicationDto staffApplicationDto) {
+        if (!isOpen()) {
+            return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
+        }
+        UUID userUuid = authenticatedUuid.getAuthenticatedUserUuid();
+
+        String email = staffApplicationDto.getEmail() == null ? null : staffApplicationDto.getEmail().toLowerCase();
+        Optional<EmailVerification> optionalEmail = fetchEmailVerification(userUuid, email);
+        if (optionalEmail.isEmpty() || !optionalEmail.get().verified()) {
+            log.warn("User {} attempted to submit an application without a verified email {}", userUuid, email);
+            return ResponseEntity.badRequest().build();
+        }
+
+        // Map and persist application
+        StaffApplication application = staffApplicationDataMapper.map(userUuid, staffApplicationDto);
+        saveApplication(application);
+
+        String username = getUsername(userUuid);
+
+        try {
+            if (!staffApplicationMail.sendApplicationEmail(username, application)) {
+                log.warn("Failed to send staff application email for {}", application.id());
+                return ResponseEntity.internalServerError().build();
+            }
+        } catch (Exception e) {
+            log.error("Error while sending staff application email for {}", application.id(), e);
+            return ResponseEntity.internalServerError().build();
+        }
+
+        try {
+            staffApplicationDiscord.sendApplicationToDiscord(username, application);
+        } catch (Exception e) {
+            log.error("Failed to send staff application {} to Discord", application.id(), e);
+            return ResponseEntity.internalServerError().build();
+        }
+        try {
+            markAsSent(application.id());
+        } catch (Exception e) {
+            log.error("Failed to mark application {} as sent", application.id(), e);
+            return ResponseEntity.internalServerError().build();
+        }
+        FormResponseDto response = buildResponse(application);
+        return ResponseEntity.status(200).body(response);
+    }
+
+    private void saveApplication(StaffApplication application) {
+        CompletableFuture<Void> saveFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sqlSession -> {
+                    try {
+                        sqlSession.getMapper(StaffApplicationMapper.class).insert(application);
+                        saveFuture.complete(null);
+                    } catch (Exception e) {
+                        log.error("Failed to insert staff application", e);
+                        saveFuture.completeExceptionally(e);
+                    }
+                });
+        saveFuture.join();
+    }
+
+    private Optional<EmailVerification> fetchEmailVerification(UUID userUuid, String email) {
+        CompletableFuture<Optional<EmailVerification>> emailVerificationFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sqlSession -> {
+                    EmailVerification verifiedMail = sqlSession.getMapper(EmailVerificationMapper.class)
+                            .findByUserAndEmail(userUuid, email);
+                    emailVerificationFuture.complete(Optional.ofNullable(verifiedMail));
+                });
+        return emailVerificationFuture.join();
+    }
+
+    private void markAsSent(UUID applicationId) {
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sqlSession -> sqlSession.getMapper(StaffApplicationMapper.class).markAsSent(applicationId));
+    }
+
+    private FormResponseDto buildResponse(StaffApplication application) {
+        String message = "Your staff application has been submitted. You will be notified when it has been reviewed.";
+        return new FormResponseDto(
+                application.id().toString(),
+                message,
+                true
+        );
+    }
+
+    private String getUsername(UUID uuid) {
+        CompletableFuture<String> usernameFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.LUCK_PERMS)
+                .runQuery(sqlSession -> {
+                    log.debug("Loading username for uuid {}", uuid);
+                    try {
+                        String username = sqlSession.getMapper(UUIDUsernameMapper.class).getUsernameFromUUID(uuid.toString());
+                        usernameFuture.complete(username);
+                    } catch (Exception e) {
+                        log.error("Failed to load username for uuid {}", uuid, e);
+                        usernameFuture.completeExceptionally(e);
+                    }
+                });
+        return usernameFuture.join();
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/controllers/forms/MailController.java

@@ -0,0 +1,104 @@
+package com.alttd.altitudeweb.controllers.forms;
+
+import com.alttd.altitudeweb.api.MailApi;
+import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerification;
+import com.alttd.altitudeweb.model.MailResponseDto;
+import com.alttd.altitudeweb.model.SubmitEmailDto;
+import com.alttd.altitudeweb.model.VerifyCodeDto;
+import com.alttd.altitudeweb.model.EmailEntryDto;
+import com.alttd.altitudeweb.services.limits.RateLimit;
+import com.alttd.altitudeweb.services.mail.MailVerificationService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+import org.springframework.http.HttpStatus;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RateLimit(limit = 60, timeValue = 1, timeUnit = TimeUnit.HOURS)
+public class MailController implements MailApi {
+
+    private final MailVerificationService mailVerificationService;
+    private final AuthenticatedUuid authenticatedUuid;
+
+    @Override
+    @RateLimit(limit = 5, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "mailSubmit")
+    public ResponseEntity<MailResponseDto> submitEmailForVerification(SubmitEmailDto submitEmailDto) {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        boolean emailAlreadyVerified = mailVerificationService.listAll(uuid).stream()
+                                           .filter(EmailVerification::verified)
+                                           .map(EmailVerification::email)
+                                           .anyMatch(mail -> mail.equalsIgnoreCase(submitEmailDto.getEmail()));
+        if (emailAlreadyVerified) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Email already verified for user");
+        }
+
+        EmailVerification saved = mailVerificationService.submitEmail(uuid, submitEmailDto.getEmail());
+        MailResponseDto response = new MailResponseDto()
+                .email(saved.email())
+                .message("Verification email sent")
+                .verified(false);
+        return ResponseEntity.status(HttpStatus.CREATED).body(response);
+    }
+
+    @Override
+    @RateLimit(limit = 20, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "mailVerify")
+    public ResponseEntity<MailResponseDto> verifyEmailCode(VerifyCodeDto verifyCodeDto) {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        Optional<EmailVerification> optionalEmailVerification = mailVerificationService.verifyCode(uuid, verifyCodeDto.getCode());
+        if (optionalEmailVerification.isEmpty()) {
+            throw new ResponseStatusException(HttpStatus.BAD_REQUEST, "Invalid verification code");
+        }
+        EmailVerification emailVerification = optionalEmailVerification.get();
+        MailResponseDto response = new MailResponseDto()
+                .email(emailVerification.email())
+                .message("Email verified successfully")
+                .verified(true);
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    @RateLimit(limit = 5, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "mailResend")
+    public ResponseEntity<MailResponseDto> resendVerificationEmail(SubmitEmailDto submitEmailDto) {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        EmailVerification updated = mailVerificationService.resend(uuid, submitEmailDto.getEmail());
+        if (updated == null) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Email not found for user");
+        }
+        MailResponseDto response = new MailResponseDto()
+                .email(updated.email())
+                .message("Verification email resent")
+                .verified(false);
+        return ResponseEntity.ok(response);
+    }
+
+    @Override
+    @RateLimit(limit = 10, timeValue = 1, timeUnit = TimeUnit.HOURS, key = "mailDelete")
+    public ResponseEntity<Void> deleteEmail(SubmitEmailDto submitEmailDto) {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        boolean deleted = mailVerificationService.delete(uuid, submitEmailDto.getEmail());
+        if (!deleted) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Email not found for user");
+        }
+        return ResponseEntity.noContent().build();
+    }
+
+    @Override
+    public ResponseEntity<List<EmailEntryDto>> getUserEmails() {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        List<EmailVerification> emails = mailVerificationService.listAll(uuid);
+        List<EmailEntryDto> result = emails.stream()
+                .map(ev -> new EmailEntryDto().email(ev.email()).verified(ev.verified()))
+                .toList();
+        return ResponseEntity.ok(result);
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/controllers/history/HistoryApiController.java

@@ -1,6 +1,7 @@
 package com.alttd.altitudeweb.controllers.history;
 
 import com.alttd.altitudeweb.api.HistoryApi;
+import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
 import com.alttd.altitudeweb.services.limits.RateLimit;
 import com.alttd.altitudeweb.model.HistoryCountDto;
 import com.alttd.altitudeweb.model.PunishmentHistoryListDto;
@@ -8,9 +9,11 @@ import com.alttd.altitudeweb.setup.Connection;
 import com.alttd.altitudeweb.database.Databases;
 import com.alttd.altitudeweb.database.litebans.*;
 import com.alttd.altitudeweb.model.PunishmentHistoryDto;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
 
 import java.util.List;
 import java.util.UUID;
@@ -20,8 +23,11 @@ import java.util.concurrent.TimeUnit;
 @Slf4j
 @RestController
 @RateLimit(limit = 30, timeValue = 10, timeUnit = TimeUnit.SECONDS)
+@RequiredArgsConstructor
 public class HistoryApiController implements HistoryApi {
 
+    private final AuthenticatedUuid authenticatedUuid;
+
     @Override
     public ResponseEntity<PunishmentHistoryListDto> getHistoryForAll(String userType, String type, Integer page) {
         return getHistoryForUsers(userType, type, "", page);
@@ -229,4 +235,108 @@ public class HistoryApiController implements HistoryApi {
                 .type(type)
                 .id(historyRecord.getId());
     }
+
+    @Override
+    public ResponseEntity<PunishmentHistoryDto> updatePunishmentReason(String type, Integer id, String reason) {
+        log.debug("Updating reason for {} id {} to {}", type, id, reason);
+        HistoryType historyTypeEnum = HistoryType.getHistoryType(type);
+        CompletableFuture<PunishmentHistoryDto> result = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.LITE_BANS).runQuery(sqlSession -> {
+            try {
+                IdHistoryMapper idMapper = sqlSession.getMapper(IdHistoryMapper.class);
+                EditHistoryMapper editMapper = sqlSession.getMapper(EditHistoryMapper.class);
+                HistoryRecord before = idMapper.getRecentHistory(historyTypeEnum, id);
+                if (before == null) {
+                    result.complete(null);
+                    return;
+                }
+                int changed = editMapper.setReason(historyTypeEnum, id, reason);
+                HistoryRecord after = idMapper.getRecentHistory(historyTypeEnum, id);
+                UUID actor = authenticatedUuid.getAuthenticatedUserUuid();
+                log.info("[Punishment Edit] Actor={} Type={} Id={} Reason: '{}' -> '{}' (rows={})",
+                         actor, historyTypeEnum, id, before.getReason(), after != null ? after.getReason() : null, changed);
+                result.complete(after != null ? mapPunishmentHistory(after) : null);
+            } catch (Exception e) {
+                log.error("Failed to update reason for {} id {}", type, id, e);
+                result.completeExceptionally(e);
+            }
+        });
+        PunishmentHistoryDto body = result.join();
+        if (body == null) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(body);
+    }
+
+    @Override
+    public ResponseEntity<PunishmentHistoryDto> updatePunishmentUntil(String type, Integer id, Long until) {
+        log.debug("Updating until for {} id {} to {}", type, id, until);
+        HistoryType historyTypeEnum = HistoryType.getHistoryType(type);
+        CompletableFuture<PunishmentHistoryDto> result = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.LITE_BANS).runQuery(sqlSession -> {
+            try {
+                IdHistoryMapper idMapper = sqlSession.getMapper(IdHistoryMapper.class);
+                EditHistoryMapper editMapper = sqlSession.getMapper(EditHistoryMapper.class);
+                HistoryRecord before = idMapper.getRecentHistory(historyTypeEnum, id);
+                if (before == null) {
+                    result.complete(null);
+                    return;
+                }
+                int changed = editMapper.setUntil(historyTypeEnum, id, until);
+                HistoryRecord after = idMapper.getRecentHistory(historyTypeEnum, id);
+                UUID actor = authenticatedUuid.getAuthenticatedUserUuid();
+                log.info("[Punishment Edit] Actor={} Type={} Id={} Until: '{}' -> '{}' (rows={})",
+                         actor, historyTypeEnum, id, before.getUntil(), after != null ? after.getUntil() : null, changed);
+                result.complete(after != null ? mapPunishmentHistory(after) : null);
+            } catch (IllegalArgumentException e) {
+                log.warn("Invalid until edit for type {} id {}: {}", type, id, e.getMessage());
+                result.complete(null);
+            } catch (Exception e) {
+                log.error("Failed to update until for {} id {}", type, id, e);
+                result.completeExceptionally(e);
+            }
+        });
+        PunishmentHistoryDto body = result.join();
+        if (body == null) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(body);
+    }
+
+    @Override
+    public ResponseEntity<Void> removePunishment(String type, Integer id) {
+        log.debug("Removing punishment for {} id {}", type, id);
+        HistoryType historyTypeEnum = HistoryType.getHistoryType(type);
+        CompletableFuture<Boolean> result = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.LITE_BANS).runQuery(sqlSession -> {
+            try {
+                IdHistoryMapper idMapper = sqlSession.getMapper(IdHistoryMapper.class);
+                EditHistoryMapper editMapper = sqlSession.getMapper(EditHistoryMapper.class);
+                HistoryRecord before = idMapper.getRecentHistory(historyTypeEnum, id);
+                if (before == null) {
+                    result.complete(false);
+                    return;
+                }
+                UUID actorUuid = authenticatedUuid.getAuthenticatedUserUuid();
+                String actorName = sqlSession.getMapper(RecentNamesMapper.class).getUsername(actorUuid.toString());
+                int changed = editMapper.remove(historyTypeEnum, id);
+                log.info("[Punishment Remove] Actor={} ({}) Type={} Id={} Before(active={} removedBy={} reason='{}') (rows={})",
+                         actorName, actorUuid, historyTypeEnum, id,
+                         before.getRemovedByName() == null ? 1 : 0, before.getRemovedByName(), before.getRemovedByReason(),
+                         changed);
+                result.complete(changed > 0);
+            } catch (Exception e) {
+                log.error("Failed to remove punishment for {} id {}", type, id, e);
+                result.completeExceptionally(e);
+            }
+        });
+        Boolean ok = result.join();
+        if (ok == null || !ok) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.noContent().build();
+    }
 }

backend/src/main/java/com/alttd/altitudeweb/controllers/login/LoginController.java

@@ -1,18 +1,22 @@
 package com.alttd.altitudeweb.controllers.login;
 
 import com.alttd.altitudeweb.api.LoginApi;
-import com.alttd.altitudeweb.model.PermissionClaimDto;
+import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
 import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.litebans.RecentNamesMapper;
 import com.alttd.altitudeweb.database.web_db.PrivilegedUser;
 import com.alttd.altitudeweb.database.web_db.PrivilegedUserMapper;
+import com.alttd.altitudeweb.model.PermissionClaimDto;
+import com.alttd.altitudeweb.model.UsernameDto;
+import com.alttd.altitudeweb.services.limits.RateLimit;
 import com.alttd.altitudeweb.setup.Connection;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.annotation.Scheduled;
-import com.alttd.altitudeweb.services.limits.RateLimit;
 import org.springframework.security.oauth2.jwt.JwtClaimsSet;
 import org.springframework.security.oauth2.jwt.JwtEncoder;
 import org.springframework.security.oauth2.jwt.JwtEncoderParameters;
@@ -28,20 +32,26 @@ import java.util.concurrent.TimeUnit;
 
 @Slf4j
 @RequiredArgsConstructor
+@EnableScheduling
 @RestController
 public class LoginController implements LoginApi {
 
     private final JwtEncoder jwtEncoder;
+    private final AuthenticatedUuid authenticatedUuid;
 
     @Value("${login.secret:#{null}}")
     private String loginSecret;
 
-    private record CacheEntry(UUID uuid, Instant expiry) {}
+    @Value("${my-server.address:#{null}}")
+    private String serverAddress;
+
+    private record CacheEntry(UUID uuid, Instant expiry) {
+    }
 
     private static final ConcurrentMap<String, CacheEntry> cache = new ConcurrentHashMap<>();
 
     @Scheduled(fixedRate = 300000) // 5 minutes in milliseconds
-    private void clearExpiredCacheEntries() {
+    protected void clearExpiredCacheEntries() {
         Instant now = Instant.now();
         int initialCacheSize = cache.size();
         cache.entrySet().removeIf(entry -> entry.getValue().expiry().isBefore(now));
@@ -58,6 +68,8 @@ public class LoginController implements LoginApi {
             return ResponseEntity.badRequest().build();
         }
 
+        log.info("{} is requesting a login code", uuid);
+
         if (authorization == null || !authorization.startsWith("SECRET ")) {
             return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
         }
@@ -73,29 +85,88 @@ public class LoginController implements LoginApi {
                                     .findFirst();
 
         if (key.isPresent()) {
+            log.info("{} got cached key: {}", uuid,  key.get());
             return ResponseEntity.ok(key.get());
         }
 
         String loginCode = generateLoginCode(uuidFromString);
+        log.info("{} received login code: {}", uuid, loginCode);
         return ResponseEntity.ok(loginCode);
     }
 
+    @Override
+    public ResponseEntity<UsernameDto> getUsername() {
+        log.debug("Loading username for logged in user");
+
+        try {
+            // Get authenticated UUID using the utility method
+            UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+            log.debug("Loaded username for logged in user {}", uuid);
+
+            // Create response with username
+            UsernameDto usernameDto = new UsernameDto();
+            usernameDto.setUsername(getUsername(uuid));
+            log.debug("Loaded username for logged in user {}", usernameDto.getUsername());
+
+            return ResponseEntity.ok(usernameDto);
+
+        } catch (ResponseStatusException e) {
+            // The utility method already throws proper exceptions, we just need to convert them to ResponseEntity
+            return ResponseEntity.status(e.getStatusCode()).build();
+        }
+    }
+
+    private String getUsername(UUID uuid) {
+        CompletableFuture<String> username = new CompletableFuture<>();
+
+        Connection.getConnection(Databases.LITE_BANS)
+                  .runQuery(sqlSession -> {
+                      log.debug("Loading all history through logged in uuid");
+                      try {
+                          String temp = sqlSession
+                                  .getMapper(RecentNamesMapper.class)
+                                  .getUsername(uuid.toString());
+                          username.complete(temp);
+                      } catch (Exception e) {
+                          log.error("Failed to find username for uuid {}", uuid, e);
+                          username.completeExceptionally(e);
+                      }
+                  });
+        return username.join();
+    }
+
+    @Value("${UNSECURED:#{false}}")
+    private boolean unsecured;
+
     @RateLimit(limit = 5, timeValue = 1, timeUnit = TimeUnit.MINUTES, key = "login")
     @Override
     public ResponseEntity<String> login(String code) {
+        if (unsecured) {
+            log.warn("Unsecured login is enabled, skipping login validation!");
+        } else {
+            log.info("Received login request with code {}", code);
+        }
         if (code == null) {
+            log.warn("Received null login code");
             return ResponseEntity.badRequest().build();
         }
 
         CacheEntry cacheEntry = cache.get(code);
-        if (cacheEntry == null || cacheEntry.expiry().isBefore(Instant.now())) {
+        if (!unsecured && (cacheEntry == null || cacheEntry.expiry().isBefore(Instant.now()))) {
+            log.warn("Received invalid login code {}", code);
             return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
         }
 
+        if (unsecured && cacheEntry == null) {
+            cacheEntry = new CacheEntry(UUID.fromString("55e46bc3-2a29-4c53-850f-dbd944dc5c5f"), Instant.now().plusSeconds(TimeUnit.DAYS.toSeconds(1)));
+        }
+
         String token = generateToken(cacheEntry.uuid);
+        log.debug("Generated token for user {} with token {}", cacheEntry.uuid, token);
 
         cache.remove(code);
 
+        log.debug("Generated token for user {}", cacheEntry.uuid);
         return ResponseEntity.ok(token);
     }
 
@@ -137,10 +208,18 @@ public class LoginController implements LoginApi {
         Connection.getConnection(Databases.DEFAULT)
                   .runQuery(sqlSession -> {
                       try {
-                        Optional<PrivilegedUser> privilegedUser = sqlSession.getMapper(PrivilegedUserMapper.class)
-                                .getUserByUuid(uuid.toString());
+                          log.debug("Loading user by uuid {}", uuid.toString());
+                          PrivilegedUserMapper mapper = sqlSession.getMapper(PrivilegedUserMapper.class);
+                          Optional<PrivilegedUser> privilegedUser = mapper
+                                  .getUserByUuid(uuid);
 
+                          if (privilegedUser.isEmpty()) {
+                              int privilegedUserId = mapper.createPrivilegedUser(uuid);
+                              privilegedUserCompletableFuture.complete(
+                                      Optional.of(new PrivilegedUser(privilegedUserId, uuid, List.of())));
+                          } else {
                               privilegedUserCompletableFuture.complete(privilegedUser);
+                          }
                       } catch (Exception e) {
                           log.error("Failed to load user by uuid", e);
                           privilegedUserCompletableFuture.completeExceptionally(e);
@@ -150,14 +229,18 @@ public class LoginController implements LoginApi {
         claimList.add(PermissionClaimDto.USER);
         privilegedUser.ifPresent(user -> user.getPermissions().forEach(permission -> {
             try {
-                claimList.add(PermissionClaimDto.valueOf(permission));
+                claimList.add(PermissionClaimDto.fromValue(permission));
+                log.debug("Added permission claim {}", permission);
             } catch (IllegalArgumentException e) {
                 log.warn("Received invalid permission claim: {}", permission);
             }
         }));
+        log.debug("Generated token for user {} with claims {}", uuid.toString(),
+                claimList.stream().map(PermissionClaimDto::getValue).toList());
         JwtClaimsSet claims = JwtClaimsSet.builder()
-                .issuer("altitudeweb")
-                .claim("authorities", claimList.stream().map(PermissionClaimDto::getValue).toList())
+                                          .issuer(serverAddress)
+                                          .claim("authorities",
+                                                  claimList.stream().map(PermissionClaimDto::getValue).toList())
                                           .issuedAt(now)
                                           .expiresAt(expiryTime)
                                           .subject(uuid.toString())

backend/src/main/java/com/alttd/altitudeweb/controllers/site/SiteController.java

@@ -0,0 +1,37 @@
+package com.alttd.altitudeweb.controllers.site;
+
+import com.alttd.altitudeweb.api.SiteApi;
+import com.alttd.altitudeweb.controllers.data_from_auth.AuthenticatedUuid;
+import com.alttd.altitudeweb.model.VoteDataDto;
+import com.alttd.altitudeweb.model.VoteStatsDto;
+import com.alttd.altitudeweb.services.limits.RateLimit;
+import com.alttd.altitudeweb.services.site.VoteService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RateLimit(limit = 2, timeValue = 10, timeUnit = TimeUnit.SECONDS)
+public class SiteController implements SiteApi {
+
+    private final VoteService voteService;
+    private final AuthenticatedUuid authenticatedUuid;
+
+    @Override
+    public ResponseEntity<VoteDataDto> getVoteStats() {
+        UUID uuid = authenticatedUuid.getAuthenticatedUserUuid();
+        Optional<VoteDataDto> optionalVoteDataDto = voteService.getVoteStats(uuid);
+        if (optionalVoteDataDto.isEmpty()) {
+            return ResponseEntity.noContent().build();
+        }
+        VoteDataDto voteDataDto = optionalVoteDataDto.get();
+        return ResponseEntity.ok(voteDataDto);
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/mappers/AppealDataMapper.java

@@ -0,0 +1,35 @@
+package com.alttd.altitudeweb.mappers;
+
+import com.alttd.altitudeweb.database.web_db.forms.Appeal;
+import com.alttd.altitudeweb.model.MinecraftAppealDto;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.util.UUID;
+
+@Service
+public class AppealDataMapper {
+    public MinecraftAppealDto appealToMinecraftAppealDto(Appeal appeal) {
+        MinecraftAppealDto minecraftAppealDto = new MinecraftAppealDto();
+        minecraftAppealDto.setAppeal(appeal.reason());
+        minecraftAppealDto.setUsername(appeal.username());
+        minecraftAppealDto.setUuid(appeal.uuid());
+        minecraftAppealDto.setEmail(appeal.email());
+        return minecraftAppealDto;
+    }
+
+    public Appeal minecraftAppealDtoToAppeal(MinecraftAppealDto minecraftAppealDto) {
+        return new Appeal(
+                UUID.randomUUID(),
+                minecraftAppealDto.getUuid(),
+                minecraftAppealDto.getPunishmentType().toString(),
+                minecraftAppealDto.getPunishmentId(),
+                minecraftAppealDto.getUsername(),
+                minecraftAppealDto.getAppeal(),
+                Instant.now(),
+                null,
+                minecraftAppealDto.getEmail(),
+                null
+        );
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/mappers/StaffApplicationDataMapper.java

@@ -0,0 +1,53 @@
+package com.alttd.altitudeweb.mappers;
+
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplication;
+import com.alttd.altitudeweb.model.StaffApplicationDto;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+public class StaffApplicationDataMapper {
+
+    /**
+     * Maps the incoming DTO and the authenticated user's UUID to a StaffApplication entity.
+     * Normalizes and prepares fields as needed (lowercase email, join availableDays, timestamps, ids).
+     */
+    public StaffApplication map(UUID userUuid, StaffApplicationDto dto) {
+        String email = dto.getEmail() == null ? null : dto.getEmail().toLowerCase();
+        String availableDaysJoined = joinList(dto.getAvailableDays());
+
+        return new StaffApplication(
+                UUID.randomUUID(),
+                userUuid,
+                email,
+                dto.getAge(),
+                dto.getDiscordUsername(),
+                Boolean.TRUE.equals(dto.getMeetsRequirements()),
+                dto.getPronouns(),
+                dto.getJoinDate(),
+                dto.getWeeklyPlaytime(),
+                availableDaysJoined,
+                dto.getAvailableTimes(),
+                dto.getPreviousExperience(),
+                dto.getPluginExperience(),
+                dto.getModeratorExpectations(),
+                dto.getAdditionalInfo(),
+                Instant.now(),
+                null,
+                null
+        );
+    }
+
+    private String joinList(List<String> list) {
+        if (list == null) return null;
+        // Avoid NPEs and trim entries
+        return list.stream()
+                .filter(s -> s != null && !s.isBlank())
+                .map(String::trim)
+                .collect(Collectors.joining(","));
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/mappers/VotingStatsRowToVoteDataDto.java

@@ -0,0 +1,62 @@
+package com.alttd.altitudeweb.mappers;
+
+import com.alttd.altitudeweb.database.votingplugin.VotingStatsRow;
+import com.alttd.altitudeweb.model.VoteDataDto;
+import com.alttd.altitudeweb.model.VoteInfoDto;
+import com.alttd.altitudeweb.model.VoteStatsDto;
+import com.alttd.altitudeweb.model.VoteStreakDto;
+import org.springframework.stereotype.Service;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Service
+public class VotingStatsRowToVoteDataDto {
+
+    public VoteDataDto map(VotingStatsRow votingStatsRow) {
+        VoteDataDto voteDataDto = new VoteDataDto();
+        voteDataDto.setVoteStats(getVoteStats(votingStatsRow));
+        voteDataDto.setVoteStreak(getVoteStreak(votingStatsRow));
+        voteDataDto.setBestVoteStreak(getBestVoteStreak(votingStatsRow));
+        voteDataDto.setAllVoteInfo(getVoteInfo(votingStatsRow.lastVotes()));
+        return voteDataDto;
+    }
+
+    private VoteStreakDto getVoteStreak(VotingStatsRow votingStatsRow) {
+        VoteStreakDto voteStreakDto = new VoteStreakDto();
+        voteStreakDto.setDailyStreak(votingStatsRow.dailyStreak());
+        voteStreakDto.setWeeklyStreak(votingStatsRow.weeklyStreak());
+        voteStreakDto.setMonthlyStreak(votingStatsRow.monthlyStreak());
+        return voteStreakDto;
+    }
+
+    private VoteStreakDto getBestVoteStreak(VotingStatsRow votingStatsRow) {
+        VoteStreakDto voteStreakDto = new VoteStreakDto();
+        voteStreakDto.setDailyStreak(votingStatsRow.bestDailyStreak());
+        voteStreakDto.setWeeklyStreak(votingStatsRow.bestWeeklyStreak());
+        voteStreakDto.setMonthlyStreak(votingStatsRow.bestMonthlyStreak());
+        return voteStreakDto;
+    }
+
+
+    private VoteStatsDto getVoteStats(VotingStatsRow votingStatsRow) {
+        VoteStatsDto voteStatsDto = new VoteStatsDto();
+        voteStatsDto.setDaily(votingStatsRow.totalVotesToday());
+        voteStatsDto.setWeekly(votingStatsRow.totalVotesThisWeek());
+        voteStatsDto.setMonthly(votingStatsRow.totalVotesThisMonth());
+        voteStatsDto.setTotal(votingStatsRow.totalVotesAllTime());
+        return voteStatsDto;
+    }
+
+    private List<VoteInfoDto> getVoteInfo(String lastVotes) {
+        return Arrays.stream(lastVotes.split("%line%"))
+                .map(voteInfo -> {
+                    String[] siteAndTimestamp = voteInfo.split("//");
+                    VoteInfoDto voteInfoDto = new VoteInfoDto();
+                    voteInfoDto.setSiteName(siteAndTimestamp[0]);
+                    voteInfoDto.setLastVoteTimestamp(Long.parseLong(siteAndTimestamp[1]));
+                    return voteInfoDto;
+                })
+                .toList();
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/services/discord/AppealDiscord.java

@@ -0,0 +1,135 @@
+package com.alttd.altitudeweb.services.discord;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.discord.OutputChannel;
+import com.alttd.altitudeweb.database.discord.OutputChannelMapper;
+import com.alttd.altitudeweb.database.litebans.HistoryCountMapper;
+import com.alttd.altitudeweb.database.litebans.HistoryRecord;
+import com.alttd.altitudeweb.database.litebans.HistoryType;
+import com.alttd.altitudeweb.database.litebans.UserType;
+import com.alttd.altitudeweb.database.web_db.forms.Appeal;
+import com.alttd.altitudeweb.setup.Connection;
+import com.alttd.webinterface.send_message.DiscordSender;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Slf4j
+@Service
+public class AppealDiscord {
+
+    private static final String OUTPUT_TYPE = "APPEAL";
+
+    public void sendAppealToDiscord(Appeal appeal, HistoryRecord history) {
+        // Fetch channels
+        CompletableFuture<List<OutputChannel>> channelsFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.DISCORD).runQuery(sql -> {
+            try {
+                List<OutputChannel> channels = sql.getMapper(OutputChannelMapper.class)
+                        .getChannelsWithOutputType(OUTPUT_TYPE);
+                channelsFuture.complete(channels);
+            } catch (Exception e) {
+                log.error("Failed to load output channels for {}", OUTPUT_TYPE, e);
+                channelsFuture.complete(new ArrayList<>());
+            }
+        });
+
+        CompletableFuture<Integer> bansF = getCountAsync(HistoryType.BAN, appeal.uuid());
+        CompletableFuture<Integer> mutesF = getCountAsync(HistoryType.MUTE, appeal.uuid());
+        CompletableFuture<Integer> warnsF = getCountAsync(HistoryType.WARN, appeal.uuid());
+        CompletableFuture<Integer> kicksF = getCountAsync(HistoryType.KICK, appeal.uuid());
+
+        List<OutputChannel> channels = channelsFuture.join();
+        int bans = bansF.join();
+        int mutes = mutesF.join();
+        int warns = warnsF.join();
+        int kicks = kicksF.join();
+
+        if (channels.isEmpty()) {
+            log.warn("No Discord output channels found for type {}. Skipping Discord send.", OUTPUT_TYPE);
+            return;
+        }
+
+        // Build embed
+        boolean active = history.getUntil() == null || history.getUntil() <= 0 || history.getUntil() > System.currentTimeMillis();
+        String createdAt = formatInstant(appeal.createdAt());
+
+        List<DiscordSender.EmbedField> fields = new ArrayList<>();
+        // Group: User
+        fields.add(new DiscordSender.EmbedField(
+                "User",
+                "Username: " + safe(appeal.username()) + "\n" +
+                        "UUID: " + safe(String.valueOf(appeal.uuid())) + "\n" +
+                        "Email: " + safe(appeal.email()) + "\n" +
+                        "Submitted: " + createdAt,
+                false
+        ));
+        // Group: Punishment
+        fields.add(new DiscordSender.EmbedField(
+                "Punishment",
+                "Type: " + safe(String.valueOf(appeal.historyType())) + "\n" +
+                        "ID: " + safe(String.valueOf(appeal.historyId())) + "\n" +
+                        "Reason: " + safe(history.getReason()) + "\n" +
+                        "Active: " + active,
+                false
+        ));
+        // Group: Previous punishments
+        fields.add(new DiscordSender.EmbedField(
+                "Previous punishments",
+                "Bans: " + bans + "\n" +
+                        "Mutes: " + mutes + "\n" +
+                        "Warnings: " + warns + "\n" +
+                        "Kicks: " + kicks,
+                true
+        ));
+
+        String description = safe(appeal.reason());
+
+        List<Long> channelIds = channels.stream()
+                .map(OutputChannel::channel)
+                .toList();
+
+        // colorRgb = null (use default), timestamp = appeal.createdAt if available
+        Instant timestamp = appeal.createdAt() != null ? appeal.createdAt() : Instant.now();
+        DiscordSender.getInstance().sendEmbedToChannels(
+                channelIds,
+                "New Appeal Submitted",
+                description,
+                fields,
+                null,
+                timestamp,
+                null
+        );
+    }
+
+    private CompletableFuture<Integer> getCountAsync(HistoryType type, java.util.UUID uuid) {
+        CompletableFuture<Integer> future = new CompletableFuture<>();
+        Connection.getConnection(Databases.LITE_BANS).runQuery(sql -> {
+            try {
+                Integer count = sql.getMapper(HistoryCountMapper.class)
+                        .getUuidPunishmentCount(type, UserType.PLAYER, uuid);
+                future.complete(count == null ? 0 : count);
+            } catch (Exception e) {
+                log.error("Failed to load punishment count for {} ({})", type, uuid, e);
+                future.complete(0);
+            }
+        });
+        return future;
+    }
+
+    private String safe(String s) {
+        return s == null ? "unknown" : s;
+    }
+
+    private String formatInstant(Instant instant) {
+        if (instant == null) return "unknown";
+        return instant.atZone(ZoneId.of("UTC"))
+                .format(DateTimeFormatter.ofPattern("yyyy MMMM dd hh:mm a '(UTC)'"));
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/services/discord/StaffApplicationDiscord.java

@@ -0,0 +1,103 @@
+package com.alttd.altitudeweb.services.discord;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.discord.OutputChannel;
+import com.alttd.altitudeweb.database.discord.OutputChannelMapper;
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplication;
+import com.alttd.altitudeweb.setup.Connection;
+import com.alttd.webinterface.send_message.DiscordSender;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+@Slf4j
+@Service
+public class StaffApplicationDiscord {
+
+    private static final String OUTPUT_TYPE = "STAFF_APPLICATION";
+
+    public void sendApplicationToDiscord(String username, StaffApplication application) {
+        // Fetch channels for staff applications
+        CompletableFuture<List<OutputChannel>> channelsFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.DISCORD).runQuery(sql -> {
+            try {
+                List<OutputChannel> channels = sql.getMapper(OutputChannelMapper.class)
+                        .getChannelsWithOutputType(OUTPUT_TYPE);
+                channelsFuture.complete(channels);
+            } catch (Exception e) {
+                log.error("Failed to load output channels for {}", OUTPUT_TYPE, e);
+                channelsFuture.complete(new ArrayList<>());
+            }
+        });
+
+        List<OutputChannel> channels = channelsFuture.join();
+        if (channels.isEmpty()) {
+            log.warn("No Discord output channels found for type {}. Skipping Discord send.", OUTPUT_TYPE);
+            return;
+        }
+
+        // Build embed content
+        List<DiscordSender.EmbedField> fields = new ArrayList<>();
+        fields.add(new DiscordSender.EmbedField(
+                "Applicant",
+                "Username: " + safe(username) + "\n" +
+                        "Discord: " + safe(application.discordUsername()) + "\n" +
+                        "Email: " + safe(application.email()) + "\n" +
+                        "Age: " + safe(String.valueOf(application.age())) + "\n" +
+                        "Meets reqs: " + (application.meetsRequirements() != null && application.meetsRequirements()),
+                false
+        ));
+        fields.add(new DiscordSender.EmbedField(
+                "Availability",
+                "Days: " + safe(application.availableDays()) + "\n" +
+                        "Times: " + safe(application.availableTimes()),
+                false
+        ));
+        fields.add(new DiscordSender.EmbedField(
+                "Experience",
+                "Previous: " + safe(application.previousExperience()) + "\n" +
+                        "Plugins: " + safe(application.pluginExperience()) + "\n" +
+                        "Expectations: " + safe(application.moderatorExpectations()),
+                false
+        ));
+        if (application.additionalInfo() != null && !application.additionalInfo().isBlank()) {
+            fields.add(new DiscordSender.EmbedField(
+                    "Additional Info",
+                    application.additionalInfo(),
+                    false
+            ));
+        }
+
+        List<Long> channelIds = channels.stream()
+                .map(OutputChannel::channel)
+                .toList();
+
+        Instant timestamp = application.createdAt() != null ? application.createdAt() : Instant.now();
+        DiscordSender.getInstance().sendEmbedToChannels(
+                channelIds,
+                "New Staff Application Submitted",
+                "Join date: " + (application.joinDate() != null ? application.joinDate().toString() : "unknown") +
+                        "\nSubmitted: " + formatInstant(timestamp),
+                fields,
+                null,
+                timestamp,
+                null
+        );
+    }
+
+    private String safe(String s) {
+        return s == null ? "unknown" : s;
+    }
+
+    private String formatInstant(Instant instant) {
+        if (instant == null) return "unknown";
+        return instant.atZone(ZoneId.of("UTC"))
+                .format(DateTimeFormatter.ofPattern("yyyy MMMM dd hh:mm a '(UTC)'"));
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/services/mail/AppealMail.java

@@ -0,0 +1,69 @@
+package com.alttd.altitudeweb.services.mail;
+
+import com.alttd.altitudeweb.database.litebans.HistoryRecord;
+import com.alttd.altitudeweb.database.web_db.forms.Appeal;
+import jakarta.mail.MessagingException;
+import jakarta.mail.internet.MimeMessage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.mail.javamail.MimeMessageHelper;
+import org.springframework.stereotype.Service;
+import org.thymeleaf.context.Context;
+import org.thymeleaf.spring6.SpringTemplateEngine;
+
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class AppealMail {
+
+    private final JavaMailSender mailSender;
+    private final SpringTemplateEngine templateEngine;
+
+    @Value("${spring.mail.username}")
+    private String fromEmail;
+
+    private static final String APPEAL_EMAIL = "[email protected]";
+
+    /**
+     * Sends an email notification about the appeal to both the user and the appeals team.
+     *
+     * @param appeal The appeal object containing all necessary information
+     */
+    public void sendAppealNotification(Appeal appeal, HistoryRecord history) {
+        try {
+            sendEmailToAppealsTeam(appeal, history);
+
+            log.info("Appeal notification emails sent successfully for appeal ID: {}", appeal.id());
+        } catch (Exception e) {
+            log.error("Failed to send appeal notification emails for appeal ID: {}", appeal.id(), e);
+        }
+    }
+
+    private void sendEmailToAppealsTeam(Appeal appeal, HistoryRecord history) throws MessagingException {
+        MimeMessage message = mailSender.createMimeMessage();
+        MimeMessageHelper helper = new MimeMessageHelper(message, true);
+
+        helper.setFrom(fromEmail);
+        helper.setTo(APPEAL_EMAIL);
+        helper.setReplyTo(appeal.email());
+        helper.setSubject("New Appeal Submitted - " + appeal.username());
+
+        Context context = new Context();
+        context.setVariable("appeal", appeal);
+        context.setVariable("history", history);
+        context.setVariable("createdAt", appeal.createdAt()
+                                               .atZone(ZoneId.of("UTC"))
+                                               .format(DateTimeFormatter.ofPattern("yyyy MMMM dd hh:mm a '(UTC)'")));
+        context.setVariable("active", history.getUntil() <= 0 || history.getUntil() > System.currentTimeMillis());
+        String content = templateEngine.process("appeal-email", context);
+
+        helper.setText(content, true);
+        mailSender.send(message);
+    }
+
+}

backend/src/main/java/com/alttd/altitudeweb/services/mail/MailVerificationService.java

@@ -0,0 +1,144 @@
+package com.alttd.altitudeweb.services.mail;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerification;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerificationMapper;
+import com.alttd.altitudeweb.setup.Connection;
+import jakarta.mail.MessagingException;
+import jakarta.mail.internet.MimeMessage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.mail.javamail.MimeMessageHelper;
+import org.springframework.stereotype.Service;
+
+import java.time.Instant;
+import java.util.Optional;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class MailVerificationService {
+
+    private final JavaMailSender mailSender;
+
+    @Value("${spring.mail.username}")
+    private String fromEmail;
+
+    public java.util.List<EmailVerification> listAll(UUID userUuid) {
+        java.util.concurrent.CompletableFuture<java.util.List<EmailVerification>> future = new java.util.concurrent.CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sql -> {
+                    EmailVerificationMapper mapper = sql.getMapper(EmailVerificationMapper.class);
+                    future.complete(mapper.findAllByUser(userUuid));
+                });
+        return future.join();
+    }
+
+    public EmailVerification submitEmail(UUID userUuid, String email) {
+        String code = generateCode();
+        Instant now = Instant.now();
+        final String finalEmail = email.toLowerCase();
+
+        CompletableFuture<EmailVerification> future = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                  .runQuery(sql -> {
+                    EmailVerificationMapper mapper = sql.getMapper(EmailVerificationMapper.class);
+                    EmailVerification existing = mapper.findByUserAndEmail(userUuid, finalEmail);
+                    EmailVerification toPersist;
+                    if (existing == null) {
+                        toPersist = new EmailVerification(UUID.randomUUID(), userUuid, finalEmail, code, false, now, null, now);
+                        mapper.insert(toPersist);
+                    } else {
+                        mapper.updateCodeAndLastSent(existing.id(), code, now);
+                        toPersist = new EmailVerification(existing.id(), userUuid, finalEmail, code, false, existing.createdAt(), null, now);
+                    }
+                    future.complete(toPersist);
+                });
+        EmailVerification saved = future.join();
+        sendVerificationEmail(saved);
+        return saved;
+    }
+
+    public Optional<EmailVerification> verifyCode(UUID userUuid, String code) {
+        CompletableFuture<Optional<EmailVerification>> future = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sql -> {
+                    EmailVerificationMapper mapper = sql.getMapper(EmailVerificationMapper.class);
+                    EmailVerification found = mapper.findByUserAndCode(userUuid, code);
+                    if (found == null) {
+                        future.complete(Optional.empty());
+                        return;
+                    }
+                    mapper.markVerified(found.id(), Instant.now());
+                    future.complete(Optional.of(found));
+                });
+        return future.join();
+    }
+
+    public EmailVerification resend(UUID userUuid, String email) {
+        String code = generateCode();
+        Instant now = Instant.now();
+        final String finalEmail = email.toLowerCase();
+        CompletableFuture<EmailVerification> future = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                  .runQuery(sql -> {
+                    EmailVerificationMapper mapper = sql.getMapper(EmailVerificationMapper.class);
+                    EmailVerification existing = mapper.findByUserAndEmail(userUuid, finalEmail);
+                    if (existing != null) {
+                        mapper.updateCodeAndLastSent(existing.id(), code, now);
+                        future.complete(new EmailVerification(existing.id(), userUuid,
+                                finalEmail, code, false, existing.createdAt(), null, now));
+                    } else {
+                        future.complete(null);
+                    }
+                });
+        EmailVerification updated = future.join();
+        if (updated != null) {
+            sendVerificationEmail(updated);
+        }
+        return updated;
+    }
+
+    public boolean delete(UUID userUuid, String email) {
+        final String finalEmail = email.toLowerCase();
+        CompletableFuture<Boolean> future = new CompletableFuture<>();
+        Connection.getConnection(Databases.DEFAULT)
+                .runQuery(sql -> {
+                    EmailVerificationMapper mapper = sql.getMapper(EmailVerificationMapper.class);
+                    EmailVerification existing = mapper.findByUserAndEmail(userUuid, finalEmail);
+                    if (existing != null) {
+                        mapper.deleteByUserAndEmail(userUuid, finalEmail);
+                        future.complete(true);
+                    } else {
+                        future.complete(false);
+                    }
+                });
+        return future.join();
+    }
+
+    private void sendVerificationEmail(EmailVerification emailVerification) {
+        try {
+            MimeMessage message = mailSender.createMimeMessage();
+            MimeMessageHelper helper = new MimeMessageHelper(message, true);
+            helper.setFrom(fromEmail);
+            helper.setTo(emailVerification.email().toLowerCase());
+            helper.setSubject("Your verification code");
+            helper.setText("Your verification code is: " + emailVerification.verificationCode(), false);
+            mailSender.send(message);
+        } catch (MessagingException e) {
+            log.error("Failed to send verification email to {}", emailVerification.email(), e);
+        }
+    }
+
+    private String generateCode() {
+        // 6-digit numeric code
+        Random random = new Random();
+        int num = 100000 + random.nextInt(899999);
+        return String.valueOf(num);
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/services/mail/StaffApplicationMail.java

@@ -0,0 +1,72 @@
+package com.alttd.altitudeweb.services.mail;
+
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplication;
+import jakarta.mail.MessagingException;
+import jakarta.mail.internet.MimeMessage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.mail.javamail.JavaMailSender;
+import org.springframework.mail.javamail.MimeMessageHelper;
+import org.springframework.stereotype.Service;
+import org.thymeleaf.context.Context;
+import org.thymeleaf.spring6.SpringTemplateEngine;
+
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class StaffApplicationMail {
+
+    private final JavaMailSender mailSender;
+    private final SpringTemplateEngine templateEngine;
+
+    @Value("${spring.mail.username}")
+    private String fromEmail;
+
+    private static final String STAFF_APPLICATION_EMAIL = "[email protected]";
+
+    /**
+     * Sends an email with the staff application details to the staff applications team mailbox.
+     * Returns true if the email was sent successfully.
+     */
+    public boolean sendApplicationEmail(String username, StaffApplication application) {
+        try {
+            doSend(username, application);
+            log.info("Staff application email sent successfully for application ID: {}", application.id());
+            return true;
+        } catch (Exception e) {
+            log.error("Failed to send staff application email for application ID: {}", application.id(), e);
+            return false;
+        }
+    }
+
+    private void doSend(String username, StaffApplication application) throws MessagingException {
+        MimeMessage message = mailSender.createMimeMessage();
+        MimeMessageHelper helper = new MimeMessageHelper(message, true);
+
+        helper.setFrom(fromEmail);
+        helper.setTo(STAFF_APPLICATION_EMAIL);
+        helper.setReplyTo(application.email());
+        helper.setSubject("Staff Application: " + safe(application.discordUsername()));
+
+        // Prepare template context
+        String createdAt = application.createdAt()
+                .atZone(ZoneId.of("UTC"))
+                .format(DateTimeFormatter.ofPattern("yyyy MMMM dd hh:mm a '(UTC)'"));
+        Context context = new Context();
+        context.setVariable("application", application);
+        context.setVariable("createdAt", createdAt);
+        context.setVariable("username", username);
+
+        String content = templateEngine.process("staff-application-email", context);
+        helper.setText(content, true);
+        mailSender.send(message);
+    }
+
+    private String safe(String s) {
+        return s == null ? "unknown" : s;
+    }
+}

backend/src/main/java/com/alttd/altitudeweb/services/site/VoteService.java

@@ -0,0 +1,47 @@
+package com.alttd.altitudeweb.services.site;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.votingplugin.VotingPluginUsersMapper;
+import com.alttd.altitudeweb.database.votingplugin.VotingStatsRow;
+import com.alttd.altitudeweb.mappers.VotingStatsRowToVoteDataDto;
+import com.alttd.altitudeweb.model.VoteDataDto;
+import com.alttd.altitudeweb.setup.Connection;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class VoteService {
+
+    private final VotingStatsRowToVoteDataDto votingStatsRowToVoteDataDto;
+
+    public Optional<VoteDataDto> getVoteStats(UUID uuid) {
+        CompletableFuture<Optional<VoteDataDto>> voteDataDtoFuture = new CompletableFuture<>();
+        Connection.getConnection(Databases.VOTING_PLUGIN).runQuery(sqlSession -> {
+            try {
+                VotingPluginUsersMapper votingPluginUsersMapper = sqlSession.getMapper(VotingPluginUsersMapper.class);
+                Optional<VotingStatsRow> optionalVotingStatsRow = votingPluginUsersMapper.getStatsByUuid(uuid);
+                if (optionalVotingStatsRow.isEmpty()) {
+                    log.debug("No voting stats found for {}", uuid);
+                    voteDataDtoFuture.complete(Optional.empty());
+                    return;
+                }
+
+                VotingStatsRow votingStatsRow = optionalVotingStatsRow.get();
+
+                VoteDataDto voteDataDto = votingStatsRowToVoteDataDto.map(votingStatsRow);
+                voteDataDtoFuture.complete(Optional.of(voteDataDto));
+            } catch (Exception e) {
+                log.error("Failed to get vote data for {}", uuid, e);
+                voteDataDtoFuture.completeExceptionally(e);
+            }
+        });
+        return voteDataDtoFuture.join();//TODO handle exception
+    }
+}

backend/src/main/resources/application-beta.properties

@@ -5,4 +5,5 @@ database.host=${DB_HOST:localhost}
 database.user=${DB_USER:root}
 database.password=${DB_PASSWORD:root}
 cors.allowed-origins=${CORS:https://beta.alttd.com}
-logging.level.com.alttd.altitudeweb=INFO
+my-server.address=${SERVER_ADDRESS:https://beta.alttd.com}
+logging.level.com.alttd.altitudeweb=DEBUG

backend/src/main/resources/application-test.properties

@@ -1,8 +1,4 @@
-spring.application.name=AltitudeWeb
-database.name=${DB_NAME:web_db}
-database.port=${DB_PORT:3306}
-database.host=${DB_HOST:localhost}
-database.user=${DB_USER:root}
-database.password=${DB_PASSWORD:root}
-cors.allowed-origins=${CORS:http://localhost:4200}
+cors.allowed-origins=${CORS:http://localhost:4200,http://localhost:8080,http://localhost:80}
+my-server.address=${SERVER_ADDRESS:http://localhost:8080}
 logging.level.com.alttd.altitudeweb=DEBUG
+logging.level.org.springframework.security=DEBUG

backend/src/main/resources/application.properties

@@ -8,4 +8,13 @@ cors.allowed-origins=${CORS:https://alttd.com}
 login.secret=${LOGIN_SECRET:SET_TOKEN}
 particles.file_path=${user.home}/.altitudeweb/particles
 notification.server.url=${SERVER_IP:10.0.0.107}:${SERVER_PORT:8080}
+my-server.address=${SERVER_ADDRESS:https://alttd.com}
 logging.level.com.alttd.altitudeweb=INFO
+discord.token=${DISCORD_TOKEN}
+spring.mail.host=${MAIL_HOST:smtp.zoho.com}
+spring.mail.port=${MAIL_PORT:465}
+spring.mail.username=${MAIL_USER}
+spring.mail.password=${MAIL_PASSWORD}
+spring.mail.properties.mail.smtp.auth=true
+spring.mail.properties.mail.smtp.ssl.enable=true
+spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory

backend/src/main/resources/templates/appeal-email.html

@@ -0,0 +1,124 @@
+<!DOCTYPE html>
+<html xmlns:th="http://www.thymeleaf.org" lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Appeal Notification</title>
+    <style>
+        @font-face {
+            font-family: 'minecraft-title';
+            src: url('https://beta.alttd.com/public/fonts/minecraft-title.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.woff') format('woff');
+        }
+
+        @font-face {
+            font-family: 'minecraft-text';
+            src: url('https://beta.alttd.com/public/fonts/minecraft-text.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.woff') format('woff');
+        }
+        
+        @font-face {
+            font-family: 'opensans';
+            src: url('https://beta.alttd.com/public/fonts/opensans.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/opensans.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/opensans.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/opensans.woff') format('woff');
+        }
+
+        @font-face {
+            font-family: 'opensans-bold';
+            src: url('https://beta.alttd.com/public/fonts/opensans-bold.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.woff') format('woff');
+        }
+
+        body {
+            font-family: 'minecraft-title', sans-serif;
+        }
+
+        .columnSection {
+            width: 80%;
+            max-width: 800px;
+            margin: 0 auto;
+            display: flex;
+        }
+
+        .columnContainer {
+            flex: 1 1 200px;
+            min-width: 200px;
+            box-sizing: border-box;
+            padding: 0 15px;
+        }
+
+        img {
+            display: block;
+            margin: auto;
+            padding-top: 10px;
+        }
+
+        ul {
+            list-style-type: none;
+            padding-left: 0;
+        }
+
+        li {
+            padding-bottom: 7px;
+        }
+
+        li, p {
+            font-family: 'opensans', sans-serif;
+            font-size: 1rem;
+        }
+
+        h2 {
+            font-size: 1.5rem;
+        }
+
+        @media (max-width: 1150px) {
+            .columnContainer, .columnSection {
+                width: 90%;
+            }
+        }
+
+        @media (max-width: 690px) {
+            .columnContainer {
+                width: 100%;
+                text-align: center;
+            }
+        }
+    </style>
+</head>
+<body>
+    <main>
+        <img id="header-img" src="https://beta.alttd.com/public/img/logos/logo.png" alt="The Altitude Minecraft Server" height="159"
+             width="275">
+        <h1 style="text-align: center;" th:text="'Appeal by ' + ${appeal.username}">Appeal by Username</h1>
+        <section class="columnSection">
+            <div class="columnContainer">
+                <div>
+                    <h2>User information</h2>
+                    <ul>
+                        <li><strong>Username:</strong> <span th:text="${appeal.username}">username</span></li>
+                        <li><strong>UUID:</strong> <span th:text="${appeal.uuid}">uuid</span></li>
+                        <li><strong>Email:</strong> <span th:text="${appeal.email}">email</span></li>
+                        <li><strong>Submitted at:</strong> <span th:text="${createdAt}">date</span></li>
+                        <li><strong>Reason:</strong> <span th:text="${history.reason}">reason</span></li>
+                        <li><strong>Active:</strong> <span th:text="${active}">unknown</span></li>
+                    </ul>
+                </div>
+            </div>
+            <div class="columnContainer">
+                <div>
+                    <h2>Appeal:</h2>
+                    <p th:text="${appeal.reason}">Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.
+                        Lorem ipsum dolor sit amet consectetur adipiscing elit. Quisque faucibus ex sapien vitae pellentesque sem placerat. In id cursus mi pretium tellus duis convallis. Tempus leo eu aenean sed diam urna tempor. Pulvinar vivamus fringilla lacus nec metus bibendum egestas. Iaculis massa nisl malesuada lacinia integer nunc posuere. Ut hendrerit semper vel class aptent taciti sociosqu. Ad litora torquent per conubia nostra inceptos himenaeos.</p>
+                </div>
+            </div>
+        </section>
+    </main>
+</body>
+</html>

backend/src/main/resources/templates/staff-application-email.html

@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<html xmlns:th="http://www.thymeleaf.org" lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Staff Application</title>
+    <style>
+        @font-face {
+            font-family: 'minecraft-title';
+            src: url('https://beta.alttd.com/public/fonts/minecraft-title.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/minecraft-title.woff') format('woff');
+        }
+
+        @font-face {
+            font-family: 'minecraft-text';
+            src: url('https://beta.alttd.com/public/fonts/minecraft-text.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/minecraft-text.woff') format('woff');
+        }
+
+        @font-face {
+            font-family: 'opensans';
+            src: url('https://beta.alttd.com/public/fonts/opensans.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/opensans.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/opensans.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/opensans.woff') format('woff');
+        }
+
+        @font-face {
+            font-family: 'opensans-bold';
+            src: url('https://beta.alttd.com/public/fonts/opensans-bold.ttf') format('truetype'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.eot') format('embedded-opentype'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.svg') format('svg'),
+            url('https://beta.alttd.com/public/fonts/opensans-bold.woff') format('woff');
+        }
+
+        body {
+            font-family: 'minecraft-title', sans-serif;
+        }
+
+        .columnSection {
+            width: 80%;
+            max-width: 800px;
+            margin: 0 auto;
+            display: flex;
+        }
+
+        .columnContainer {
+            flex: 1 1 200px;
+            min-width: 200px;
+            box-sizing: border-box;
+            padding: 0 15px;
+        }
+
+        img {
+            display: block;
+            margin: auto;
+            padding-top: 10px;
+        }
+
+        ul {
+            list-style-type: none;
+            padding-left: 0;
+        }
+
+        li {
+            padding-bottom: 7px;
+        }
+
+        li, p {
+            font-family: 'opensans', sans-serif;
+            font-size: 1rem;
+        }
+
+        h2 {
+            font-size: 1.5rem;
+        }
+
+        @media (max-width: 1150px) {
+            .columnContainer, .columnSection {
+                width: 90%;
+            }
+        }
+
+        @media (max-width: 690px) {
+            .columnContainer {
+                width: 100%;
+                text-align: center;
+            }
+        }
+    </style>
+</head>
+<body>
+<main>
+    <img id="header-img" src="https://beta.alttd.com/public/img/logos/logo.png" alt="The Altitude Minecraft Server" height="159" width="275">
+    <h1 style="text-align: center;" th:text="'Staff application by ' + ${application.discordUsername}">Staff application</h1>
+
+    <section class="columnSection">
+        <div class="columnContainer">
+            <div>
+                <h2>Applicant</h2>
+                <ul>
+                    <li><strong>Username:</strong> <span th:text="${username}">uuid</span></li>
+                    <li><strong>Email:</strong> <span th:text="${application.email}">email</span></li>
+                    <li><strong>Discord:</strong> <span th:text="${application.discordUsername}">discord</span></li>
+                    <li><strong>Age:</strong> <span th:text="${application.age}">age</span></li>
+                    <li><strong>Pronouns:</strong> <span th:text="${application.pronouns}">pronouns</span></li>
+                    <li><strong>Join date:</strong> <span th:text="${application.joinDate}">date</span></li>
+                    <li><strong>Submitted at:</strong> <span th:text="${createdAt}">date</span></li>
+                </ul>
+            </div>
+        </div>
+        <div class="columnContainer">
+            <div>
+                <h2>Availability</h2>
+                <ul>
+                    <li><strong>Days:</strong> <span th:text="${application.availableDays}">days</span></li>
+                    <li><strong>Times:</strong> <span th:text="${application.availableTimes}">times</span></li>
+                    <li><strong>Weekly playtime:</strong> <span th:text="${application.weeklyPlaytime}">0</span> hours</li>
+                </ul>
+
+                <h2>Experience</h2>
+                <p><strong>Previous:</strong><br><span th:text="${application.previousExperience}">previous experience</span></p>
+                <p><strong>Plugins:</strong><br><span th:text="${application.pluginExperience}">plugin experience</span></p>
+                <p><strong>Expectations:</strong><br><span th:text="${application.moderatorExpectations}">moderator expectations</span></p>
+
+                <div th:if="${application.additionalInfo} != null and ${application.additionalInfo} != ''">
+                    <h2>Additional info</h2>
+                    <p th:text="${application.additionalInfo}">additional info</p>
+                </div>
+            </div>
+        </div>
+    </section>
+</main>
+</body>
+</html>

database/src/main/java/com/alttd/altitudeweb/database/Databases.java

@@ -6,7 +6,9 @@ import lombok.Getter;
 public enum Databases {
     DEFAULT("web_db"),
     LUCK_PERMS("luckperms"),
-    LITE_BANS("litebans");
+    LITE_BANS("litebans"),
+    DISCORD("discordLink"),
+    VOTING_PLUGIN("votingplugin");
 
     private final String internalName;
 

database/src/main/java/com/alttd/altitudeweb/database/discord/OutputChannel.java

@@ -0,0 +1,4 @@
+package com.alttd.altitudeweb.database.discord;
+
+public record OutputChannel(long guild, String outputType, long channel, String channelType) {
+}

database/src/main/java/com/alttd/altitudeweb/database/discord/OutputChannelMapper.java

@@ -0,0 +1,15 @@
+package com.alttd.altitudeweb.database.discord;
+
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+public interface OutputChannelMapper {
+    @Select("""
+            SELECT guild, output_type, channel, channel_type
+            FROM output_channels
+            WHERE output_type = #{outputType}
+            """)
+    List<OutputChannel> getChannelsWithOutputType(@Param("outputType") String outputType);
+}

database/src/main/java/com/alttd/altitudeweb/database/litebans/EditHistoryMapper.java

@@ -0,0 +1,64 @@
+package com.alttd.altitudeweb.database.litebans;
+
+import org.apache.ibatis.annotations.Delete;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Update;
+import org.jetbrains.annotations.NotNull;
+
+public interface EditHistoryMapper {
+
+    @Update("""
+            UPDATE ${table_name}
+            SET reason = #{reason}
+            WHERE id = #{id}
+            """)
+    int updateReason(@Param("table_name") String tableName,
+                     @Param("id") int id,
+                     @Param("reason") String reason);
+
+    @Update("""
+            UPDATE ${table_name}
+            SET until = #{until}
+            WHERE id = #{id}
+            """)
+    int updateUntil(@Param("table_name") String tableName,
+                    @Param("id") int id,
+                    @Param("until") Long until);
+
+    @Delete("""
+            DELETE FROM ${table_name}
+            WHERE id = #{id}
+            """)
+    int deletePunishment(@Param("table_name") String tableName,
+                         @Param("id") int id);
+
+    default int setReason(@NotNull HistoryType type, int id, String reason) {
+        return switch (type) {
+            case ALL -> throw new IllegalArgumentException("HistoryType.ALL is not supported");
+            case BAN -> updateReason("litebans_bans", id, reason);
+            case MUTE -> updateReason("litebans_mutes", id, reason);
+            case KICK -> updateReason("litebans_kicks", id, reason);
+            case WARN -> updateReason("litebans_warnings", id, reason);
+        };
+    }
+
+    default int setUntil(@NotNull HistoryType type, int id, Long until) {
+        return switch (type) {
+            case ALL -> throw new IllegalArgumentException("HistoryType.ALL is not supported");
+            case BAN -> updateUntil("litebans_bans", id, until);
+            case MUTE -> updateUntil("litebans_mutes", id, until);
+            case KICK -> throw new IllegalArgumentException("KICK has no until");
+            case WARN -> throw new IllegalArgumentException("WARN has no until");
+        };
+    }
+
+    default int remove(@NotNull HistoryType type, int id) {
+        return switch (type) {
+            case ALL -> throw new IllegalArgumentException("HistoryType.ALL is not supported");
+            case BAN -> deletePunishment("litebans_bans", id);
+            case MUTE -> deletePunishment("litebans_mutes", id);
+            case KICK -> deletePunishment("litebans_kicks", id);
+            case WARN -> deletePunishment("litebans_warnings", id);
+        };
+    }
+}

database/src/main/java/com/alttd/altitudeweb/database/litebans/RecentNamesMapper.java

@@ -7,6 +7,17 @@ import java.util.ArrayList;
 import java.util.List;
 
 public interface RecentNamesMapper {
+
+    @Select("""
+            SELECT DISTINCT name AS username
+            FROM litebans_history
+            WHERE uuid = #{uuid}
+            ORDER BY date DESC
+            LIMIT 1;
+            """)
+    String getUsername(@Param("uuid") String uuid);
+
+
     @Select("""
             SELECT DISTINCT user_lookup.name AS punished_name
             FROM ${tableName} AS punishment

database/src/main/java/com/alttd/altitudeweb/database/luckperms/UUIDUsernameMapper.java

@@ -0,0 +1,13 @@
+package com.alttd.altitudeweb.database.luckperms;
+
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+public interface UUIDUsernameMapper {
+    @Select("""
+            SELECT username
+            FROM luckperms_players
+            WHERE uuid = #{uuid}
+            """)
+    String getUsernameFromUUID(@Param("uuid") String uuid);
+}

database/src/main/java/com/alttd/altitudeweb/database/votingplugin/VotingPluginUsersMapper.java

@@ -0,0 +1,28 @@
+package com.alttd.altitudeweb.database.votingplugin;
+
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public interface VotingPluginUsersMapper {
+
+    @Select("""
+             SELECT
+                 LastVotes as lastVotes,
+                 BestDayVoteStreak as bestDailyStreak,
+                 BestWeekVoteStreak as bestWeeklyStreak,
+                 BestMonthVoteStreak as bestMonthlyStreak,
+                 DayVoteStreak as dailyStreak,
+                 WeekVoteStreak as weeklyStreak,
+                 MonthVoteStreak as monthlyStreak,
+                 DailyTotal as totalVotesToday,
+                 WeeklyTotal as totalVotesThisWeek,
+                 MonthTotal as totalVotesThisMonth,
+                 AllTimeTotal as totalVotesAllTime
+             FROM votingplugin.votingplugin_users
+             WHERE uuid = #{uuid}
+            """)
+    Optional<VotingStatsRow> getStatsByUuid(@Param("uuid") UUID uuid);
+}

database/src/main/java/com/alttd/altitudeweb/database/votingplugin/VotingStatsRow.java

@@ -0,0 +1,15 @@
+package com.alttd.altitudeweb.database.votingplugin;
+
+public record VotingStatsRow(
+        String lastVotes,
+        Integer bestDailyStreak,
+        Integer bestWeeklyStreak,
+        Integer bestMonthlyStreak,
+        Integer dailyStreak,
+        Integer weeklyStreak,
+        Integer monthlyStreak,
+        Integer totalVotesToday,
+        Integer totalVotesThisWeek,
+        Integer totalVotesThisMonth,
+        Integer totalVotesAllTime
+        ) { }

database/src/main/java/com/alttd/altitudeweb/database/web_db/KeyPairMapper.java

@@ -4,7 +4,12 @@ import org.apache.ibatis.annotations.*;
 
 public interface KeyPairMapper {
     
-    @Select("SELECT * FROM key_pair ORDER BY id DESC LIMIT 1")
+    @Select("""
+            SELECT id, private_key AS privateKey, public_key AS publicKey, created_at AS createdAt
+            FROM key_pair
+            ORDER BY id
+                DESC LIMIT 1
+            """)
     KeyPairEntity getKeyPair();
     
     @Insert("""

database/src/main/java/com/alttd/altitudeweb/database/web_db/PrivilegedUser.java

@@ -5,12 +5,13 @@ import lombok.Data;
 import lombok.NoArgsConstructor;
 
 import java.util.List;
+import java.util.UUID;
 
 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 public class PrivilegedUser {
-    private int id;
-    private String uuid;
+    private Integer id;
+    private UUID uuid;
     private List<String> permissions;
 }

database/src/main/java/com/alttd/altitudeweb/database/web_db/PrivilegedUserMapper.java

@@ -5,19 +5,19 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 
 public interface PrivilegedUserMapper {
 
     /**
      * Retrieves a user by their UUID along with their permissions
      * @param uuid The UUID of the user to retrieve
-     * @return The PrivilegedUser with their permissions, or null if not found
+     * @return The optional PrivilegedUser with their permissions
      */
     @Select("""
-            SELECT privileged_users.id, privileged_users.uuid, privileges.privileges as permission
+        SELECT id, uuid
         FROM privileged_users
-            LEFT JOIN privileges ON privileged_users.id = privileges.user_id
-            WHERE privileged_users.uuid = #{uuid}
+        WHERE uuid = #{uuid}
         """)
     @Results({
             @Result(property = "id", column = "id"),
@@ -25,7 +25,7 @@ public interface PrivilegedUserMapper {
             @Result(property = "permissions", column = "id", javaType = List.class,
                     many = @Many(select = "getPermissionsForUser"))
     })
-    Optional<PrivilegedUser> getUserByUuid(@Param("uuid") String uuid);
+    Optional<PrivilegedUser> getUserByUuid(@Param("uuid") UUID uuid);
 
     /**
      * Retrieves all privileged users with their permissions
@@ -101,4 +101,11 @@ public interface PrivilegedUserMapper {
             WHERE user_id = #{userId} AND privileges = #{permission}
             """)
     int removePermissionFromUser(@Param("userId") int userId, @Param("permission") String permission);
+
+    @Insert("""
+            INSERT INTO privileged_users (uuid)
+            VALUES (#{uuid})
+            """)
+    @Options(useGeneratedKeys = true, keyProperty = "id", keyColumn = "id")
+    int createPrivilegedUser(UUID uuid);
 }

database/src/main/java/com/alttd/altitudeweb/database/web_db/SettingsMapper.java

@@ -3,6 +3,6 @@ package com.alttd.altitudeweb.database.web_db;
 import org.apache.ibatis.annotations.Select;
 
 public interface SettingsMapper {
-    @Select("SELECT host, port, name, username, password FROM db_connection_settings WHERE name = #{database}")
+    @Select("SELECT host, port, name, username, password FROM db_connection_settings WHERE internal_name = #{database}")
     DatabaseSettings getSettings(String database);
 }

database/src/main/java/com/alttd/altitudeweb/database/web_db/forms/Appeal.java

@@ -0,0 +1,18 @@
+package com.alttd.altitudeweb.database.web_db.forms;
+
+import java.time.Instant;
+import java.util.UUID;
+
+public record Appeal(
+        UUID id,
+        UUID uuid,
+        String historyType,
+        Integer historyId,
+        String username,
+        String reason,
+        Instant createdAt,
+        Instant sendAt,
+        String email,
+        Long assignedTo
+) {
+}

database/src/main/java/com/alttd/altitudeweb/database/web_db/forms/AppealMapper.java

@@ -0,0 +1,37 @@
+package com.alttd.altitudeweb.database.web_db.forms;
+
+import org.apache.ibatis.annotations.Insert;
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.annotations.Update;
+
+import java.util.List;
+import java.util.UUID;
+
+public interface AppealMapper {
+
+    @Insert("""
+            INSERT INTO appeals (uuid, username, historyType, historyId, reason, created_at, send_at, e_mail, assigned_to)
+            VALUES (#{uuid}, #{username}, #{historyType}, #{historyId}, #{reason}, #{createdAt}, #{sendAt}, #{email}, #{assignedTo})
+            """)
+    void createAppeal(Appeal appeal);
+
+    @Select("""
+            SELECT id, uuid, historyType, historyId, reason, created_at AS createdAt, send_at AS sendAt, e_mail AS email, assigned_to AS assignedTo
+            FROM appeals
+            WHERE id = #{id}
+            """)
+    Appeal getAppealById(int id);
+
+    @Select("""
+            SELECT id, uuid, historyType, historyId, reason, created_at AS createdAt, send_at AS sendAt, e_mail AS email, assigned_to AS assignedTo
+            FROM appeals
+            WHERE uuid = #{uuid}
+            """)
+    List<Appeal> getAppealsByUuid(String uuid);
+
+    @Update("""
+            UPDATE appeals SET send_at = NOW()
+            WHERE id = #{id}
+            """)
+    void markAppealAsSent(UUID id);
+}

database/src/main/java/com/alttd/altitudeweb/database/web_db/forms/StaffApplication.java

@@ -0,0 +1,28 @@
+package com.alttd.altitudeweb.database.web_db.forms;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.UUID;
+
+public record StaffApplication(
+        UUID id,
+        UUID uuid,
+        String email,
+        Integer age,
+        String discordUsername,
+        Boolean meetsRequirements,
+        String pronouns,
+        LocalDate joinDate,
+        Integer weeklyPlaytime,
+        String availableDays,
+        String availableTimes,
+        String previousExperience,
+        String pluginExperience,
+        String moderatorExpectations,
+        String additionalInfo,
+        Instant createdAt,
+        Instant sendAt,
+        Long assignedTo
+) {
+}

database/src/main/java/com/alttd/altitudeweb/database/web_db/forms/StaffApplicationMapper.java

@@ -0,0 +1,29 @@
+package com.alttd.altitudeweb.database.web_db.forms;
+
+import org.apache.ibatis.annotations.*;
+
+import java.util.UUID;
+
+public interface StaffApplicationMapper {
+
+    @Insert("""
+            INSERT INTO staff_applications (
+                id, uuid, email, age, discord_username, meets_requirements, pronouns, join_date,
+                weekly_playtime, available_days, available_times, previous_experience, plugin_experience,
+                moderator_expectations, additional_info, created_at, send_at, assigned_to
+            ) VALUES (
+                #{id}, #{uuid}, #{email}, #{age}, #{discordUsername}, #{meetsRequirements}, #{pronouns}, #{joinDate},
+                #{weeklyPlaytime},
+                #{availableDays},
+                #{availableTimes}, #{previousExperience}, #{pluginExperience},
+                #{moderatorExpectations}, #{additionalInfo}, #{createdAt}, #{sendAt}, #{assignedTo}
+            )
+            """)
+    void insert(StaffApplication application);
+
+    @Update("""
+            UPDATE staff_applications SET send_at = NOW()
+            WHERE id = #{id}
+            """)
+    void markAsSent(@Param("id") UUID id);
+}

database/src/main/java/com/alttd/altitudeweb/database/web_db/mail/EmailVerification.java

@@ -0,0 +1,16 @@
+package com.alttd.altitudeweb.database.web_db.mail;
+
+import java.time.Instant;
+import java.util.UUID;
+
+public record EmailVerification(
+        UUID id,
+        UUID userUuid,
+        String email,
+        String verificationCode,
+        boolean verified,
+        Instant createdAt,
+        Instant verifiedAt,
+        Instant lastSentAt
+) {
+}

database/src/main/java/com/alttd/altitudeweb/database/web_db/mail/EmailVerificationMapper.java

@@ -0,0 +1,58 @@
+package com.alttd.altitudeweb.database.web_db.mail;
+
+import org.apache.ibatis.annotations.*;
+
+import java.time.Instant;
+import java.util.UUID;
+
+public interface EmailVerificationMapper {
+
+    @Insert("""
+            INSERT INTO user_emails (id, user_uuid, email, verification_code, verified, created_at, last_sent_at)
+            VALUES (#{id}, #{userUuid}, #{email}, #{verificationCode}, #{verified}, #{createdAt}, #{lastSentAt})
+            """)
+    void insert(EmailVerification emailVerification);
+
+    @Select("""
+            SELECT id, user_uuid AS userUuid, email, verification_code AS verificationCode, verified,
+                   created_at AS createdAt, verified_at AS verifiedAt, last_sent_at AS lastSentAt
+            FROM user_emails
+            WHERE user_uuid = #{userUuid} AND email = #{email}
+            """)
+    EmailVerification findByUserAndEmail(@Param("userUuid") UUID userUuid, @Param("email") String email);
+
+    @Select("""
+            SELECT id, user_uuid AS userUuid, email, verification_code AS verificationCode, verified,
+                   created_at AS createdAt, verified_at AS verifiedAt, last_sent_at AS lastSentAt
+            FROM user_emails
+            WHERE user_uuid = #{userUuid} AND verification_code = #{code}
+            ORDER BY created_at DESC LIMIT 1
+            """)
+    EmailVerification findByUserAndCode(@Param("userUuid") UUID userUuid, @Param("code") String code);
+
+    @Select("""
+            SELECT id, user_uuid AS userUuid, email, verification_code AS verificationCode, verified,
+                   created_at AS createdAt, verified_at AS verifiedAt, last_sent_at AS lastSentAt
+            FROM user_emails
+            WHERE user_uuid = #{userUuid}
+            ORDER BY created_at ASC
+            """)
+    java.util.List<EmailVerification> findAllByUser(@Param("userUuid") UUID userUuid);
+
+    @Update("""
+            UPDATE user_emails SET verified = 1, verified_at = #{verifiedAt}
+            WHERE id = #{id}
+            """)
+    void markVerified(@Param("id") UUID id, @Param("verifiedAt") Instant verifiedAt);
+
+    @Update("""
+            UPDATE user_emails SET verification_code = #{code}, last_sent_at = #{lastSentAt}, verified = 0, verified_at = NULL
+            WHERE id = #{id}
+            """)
+    void updateCodeAndLastSent(@Param("id") UUID id, @Param("code") String code, @Param("lastSentAt") Instant lastSentAt);
+
+    @Delete("""
+            DELETE FROM user_emails WHERE user_uuid = #{userUuid} AND email = #{email}
+            """)
+    void deleteByUserAndEmail(@Param("userUuid") UUID userUuid, @Param("email") String email);
+}

database/src/main/java/com/alttd/altitudeweb/setup/Connection.java

@@ -3,6 +3,7 @@ package com.alttd.altitudeweb.setup;
 import com.alttd.altitudeweb.database.Databases;
 import com.alttd.altitudeweb.database.web_db.DatabaseSettings;
 import com.alttd.altitudeweb.database.web_db.SettingsMapper;
+import com.alttd.altitudeweb.type_handler.UUIDTypeHandler;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.ibatis.datasource.pooled.PooledDataSource;
 import org.apache.ibatis.mapping.Environment;
@@ -11,9 +12,12 @@ import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.HashMap;
+import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
 import java.util.function.Consumer;
 
 @Slf4j
@@ -33,6 +37,8 @@ public class Connection {
         InitializeWebDb.init();
         InitializeLiteBans.init();
         InitializeLuckPerms.init();
+        InitializeDiscord.init();
+        InitializeVotingPlugin.init();
     }
 
     @FunctionalInterface
@@ -54,25 +60,46 @@ public class Connection {
         if (database == Databases.DEFAULT) {
             return loadDefaultDatabase(addMappers);
         }
-        CompletableFuture<DatabaseSettings> settingsFuture = new CompletableFuture<>();
-        getConnection(Databases.DEFAULT, (mapper -> mapper.addMapper(SettingsMapper.class))).thenApply(connection -> {
+
         log.debug("Loading settings for database {}", database.getInternalName());
+        CompletableFuture<DatabaseSettings> settingsFuture = new CompletableFuture<>();
+
+        getConnection(Databases.DEFAULT, (mapper -> mapper.addMapper(SettingsMapper.class))).thenApply(connection -> {
             connection.runQuery(session -> {
-                log.debug("Running query to load settings for database");
+                try {
+                    log.debug("Running query to load settings for database {}", database.getInternalName());
                     DatabaseSettings loadedSettings = session.getMapper(SettingsMapper.class).getSettings(database.getInternalName());
+
                     if (loadedSettings == null) {
-                    log.error("Failed to load settings for database {}", database.getInternalName());
-                }
-                log.debug("Loaded settings {}", loadedSettings);
+                        log.error("Failed to load settings for database {}. No settings found in db_connection_settings table.",
+                                database.getInternalName());
+                        settingsFuture.completeExceptionally(new IllegalStateException(
+                                "Database settings for " + database.getInternalName() + " not found in db_connection_settings table"));
+                    } else {
+                        log.debug("Loaded settings for database {}: host={}, port={}, name={}",
+                                database.getInternalName(), loadedSettings.host(), loadedSettings.port(), loadedSettings.name());
                         settingsFuture.complete(loadedSettings);
+                    }
+                } catch (Exception e) {
+                    log.error("Error occurred while loading database settings for {}", database.getInternalName(), e);
+                    settingsFuture.completeExceptionally(e);
+                }
             });
             return null;
+        }).exceptionally(ex -> {
+            log.error("Failed to access DEFAULT database to load settings for {}", database.getInternalName(), ex);
+            settingsFuture.completeExceptionally(ex);
+            return null;
         });
+
         return settingsFuture.thenApply(loadedSettings -> {
             log.debug("Storing connection for database {}", database.getInternalName());
             Connection connection = new Connection(loadedSettings, addMappers);
             connections.put(database, connection);
             return connection;
+        }).exceptionally(ex -> {
+            log.error("Failed to create connection for database {}", database.getInternalName(), ex);
+            throw new CompletionException("Failed to initialize database connection for " + database.getInternalName(), ex);
         });
     }
 
@@ -97,26 +124,66 @@ public class Connection {
                 sqlSessionFactory = createSqlSessionFactory(settings, addMappers);
             }
 
-            try (SqlSession session = sqlSessionFactory.openSession()) {
+            SqlSession session = null;
+            try {
+                session = sqlSessionFactory.openSession();
                 consumer.accept(session);
+                session.commit();
             } catch (Exception e) {
+                if (session != null) {
+                    session.rollback();
+                }
                 log.error("Failed to run query", e);
+            } finally {
+                if (session != null) {
+                    session.close();
+                }
             }
         }).start();
     }
 
     private SqlSessionFactory createSqlSessionFactory(DatabaseSettings settings, AddMappers addMappers) {
-        PooledDataSource dataSource = new PooledDataSource();
-        dataSource.setDriver("com.mysql.cj.jdbc.Driver");
-        dataSource.setUrl(String.format("jdbc:mysql://%s:%d/%s", settings.host(),
-                                        settings.port(), settings.name()));
-        dataSource.setUsername(settings.username());
-        dataSource.setPassword(settings.password());
-        Environment environment = new Environment("production", new JdbcTransactionFactory(), dataSource);
-        Configuration configuration = new Configuration(environment);
+        try {
+            Configuration configuration = getConfiguration(settings);
+            configuration.getTypeHandlerRegistry().register(UUID.class, UUIDTypeHandler.class);
             addMappers.apply(configuration);
 
             return new SqlSessionFactoryBuilder().build(configuration);
+        } catch (Exception e) {
+            log.error("""
+                    Failed to create sql session factory with
+                    \thost {}
+                    \tport: {}
+                    \tname: {}
+                    \tusername: {}
+                    """, settings.host(), settings.port(), settings.name(), settings.username(), e);
+            throw e;
+        }
+    }
+
+    private static @NotNull Configuration getConfiguration(DatabaseSettings settings) {
+        PooledDataSource dataSource = new PooledDataSource();
+        dataSource.setDriver("com.mysql.cj.jdbc.Driver");
+
+        String url = String.format(
+                "jdbc:mysql://%s:%d/%s?useSSL=true&tcpKeepAlive=true&socketTimeout=60000&connectTimeout=10000&autoReconnect=false&useUnicode=true&characterEncoding=utf8",
+                settings.host(),
+                settings.port(),
+                settings.name()
+                                  );
+        dataSource.setUrl(url);
+        dataSource.setUsername(settings.username());
+        dataSource.setPassword(settings.password());
+
+        dataSource.setPoolMaximumActiveConnections(10);
+        dataSource.setPoolMaximumIdleConnections(5);
+        dataSource.setPoolTimeToWait(20000);
+        dataSource.setPoolPingEnabled(true);
+        dataSource.setPoolPingQuery("SELECT 1");
+        dataSource.setPoolPingConnectionsNotUsedFor(300000); // 5 min
+
+        Environment environment = new Environment("production", new JdbcTransactionFactory(), dataSource);
+        return new Configuration(environment);
     }
 
 }

database/src/main/java/com/alttd/altitudeweb/setup/InitializeDiscord.java

@@ -0,0 +1,19 @@
+package com.alttd.altitudeweb.setup;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.discord.OutputChannelMapper;
+import com.alttd.altitudeweb.database.luckperms.TeamMemberMapper;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class InitializeDiscord {
+
+    protected static void init() {
+        log.info("Initializing Discord");
+        Connection.getConnection(Databases.DISCORD, (configuration) -> {
+            configuration.addMapper(OutputChannelMapper.class);
+        }).join();
+        log.debug("Initialized Discord");
+    }
+
+}

database/src/main/java/com/alttd/altitudeweb/setup/InitializeLiteBans.java

@@ -19,6 +19,7 @@ public class InitializeLiteBans {
                     configuration.addMapper(UUIDHistoryMapper.class);
                     configuration.addMapper(HistoryCountMapper.class);
                     configuration.addMapper(IdHistoryMapper.class);
+                    configuration.addMapper(EditHistoryMapper.class);
                 }).join()
                 .runQuery(sqlSession -> {
                     createAllPunishmentsView(sqlSession);

database/src/main/java/com/alttd/altitudeweb/setup/InitializeLuckPerms.java

@@ -2,6 +2,7 @@ package com.alttd.altitudeweb.setup;
 
 import com.alttd.altitudeweb.database.Databases;
 import com.alttd.altitudeweb.database.luckperms.TeamMemberMapper;
+import com.alttd.altitudeweb.database.luckperms.UUIDUsernameMapper;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
@@ -11,6 +12,7 @@ public class InitializeLuckPerms {
         log.info("Initializing LuckPerms");
         Connection.getConnection(Databases.LUCK_PERMS, (configuration) -> {
             configuration.addMapper(TeamMemberMapper.class);
+            configuration.addMapper(UUIDUsernameMapper.class);
         }).join();
         log.debug("Initialized LuckPerms");
     }

database/src/main/java/com/alttd/altitudeweb/setup/InitializeVotingPlugin.java

@@ -0,0 +1,17 @@
+package com.alttd.altitudeweb.setup;
+
+import com.alttd.altitudeweb.database.Databases;
+import com.alttd.altitudeweb.database.votingplugin.VotingPluginUsersMapper;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class InitializeVotingPlugin {
+
+    protected static void init() {
+        log.info("Initializing VotingPlugin");
+        Connection.getConnection(Databases.VOTING_PLUGIN, (configuration) -> {
+            configuration.addMapper(VotingPluginUsersMapper.class);
+        }).join();
+        log.debug("Initialized VotingPlugin");
+    }
+}

database/src/main/java/com/alttd/altitudeweb/setup/InitializeWebDb.java

@@ -4,6 +4,9 @@ import com.alttd.altitudeweb.database.Databases;
 import com.alttd.altitudeweb.database.web_db.KeyPairMapper;
 import com.alttd.altitudeweb.database.web_db.PrivilegedUserMapper;
 import com.alttd.altitudeweb.database.web_db.SettingsMapper;
+import com.alttd.altitudeweb.database.web_db.forms.AppealMapper;
+import com.alttd.altitudeweb.database.web_db.forms.StaffApplicationMapper;
+import com.alttd.altitudeweb.database.web_db.mail.EmailVerificationMapper;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.ibatis.session.SqlSession;
 import org.jetbrains.annotations.NotNull;
@@ -20,12 +23,18 @@ public class InitializeWebDb {
                       configuration.addMapper(SettingsMapper.class);
                       configuration.addMapper(KeyPairMapper.class);
                       configuration.addMapper(PrivilegedUserMapper.class);
+                      configuration.addMapper(AppealMapper.class);
+                      configuration.addMapper(StaffApplicationMapper.class);
+                      configuration.addMapper(EmailVerificationMapper.class);
                   }).join()
-                .runQuery(SqlSession -> {
-                    createSettingsTable(SqlSession);
-                    createKeyTable(SqlSession);
-                    createPrivilegedUsersTable(SqlSession);
-                    createPrivilegesTable(SqlSession);
+                  .runQuery(sqlSession -> {
+                      createSettingsTable(sqlSession);
+                      createKeyTable(sqlSession);
+                      createPrivilegedUsersTable(sqlSession);
+                      createPrivilegesTable(sqlSession);
+                      createAppealTable(sqlSession);
+                      createStaffApplicationsTable(sqlSession);
+                      createUserEmailsTable(sqlSession);
                   });
         log.debug("Initialized WebDb");
     }
@@ -70,7 +79,7 @@ public class InitializeWebDb {
         String query = """
                 CREATE TABLE IF NOT EXISTS privileged_users (
                     id int NOT NULL AUTO_INCREMENT PRIMARY KEY,
-                    uuid VARCHAR(36) NOT NULL
+                    uuid UUID UNIQUE NOT NULL
                 );
                 """;
         try (Statement statement = sqlSession.getConnection().createStatement()) {
@@ -99,4 +108,79 @@ public class InitializeWebDb {
         }
     }
 
+    private static void createUserEmailsTable(@NotNull SqlSession sqlSession) {
+        String query = """
+                CREATE TABLE IF NOT EXISTS user_emails (
+                    id UUID NOT NULL DEFAULT (UUID()) PRIMARY KEY,
+                    user_uuid UUID NOT NULL,
+                    email VARCHAR(255) NOT NULL,
+                    verification_code VARCHAR(16) NOT NULL,
+                    verified BOOLEAN NOT NULL DEFAULT 0,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+                    verified_at TIMESTAMP NULL,
+                    last_sent_at TIMESTAMP NULL,
+                    FOREIGN KEY (user_uuid) REFERENCES privileged_users(uuid) ON DELETE CASCADE ON UPDATE CASCADE
+                );
+                """;
+        try (Statement statement = sqlSession.getConnection().createStatement()) {
+            statement.execute(query);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static void createStaffApplicationsTable(@NotNull SqlSession sqlSession) {
+        String query = """
+                CREATE TABLE IF NOT EXISTS staff_applications (
+                    id UUID NOT NULL DEFAULT (UUID()) PRIMARY KEY,
+                    uuid UUID NOT NULL,
+                    email VARCHAR(320) NOT NULL,
+                    age INT NOT NULL,
+                    discord_username VARCHAR(32) NOT NULL,
+                    meets_requirements BOOLEAN NOT NULL,
+                    pronouns VARCHAR(32) NULL,
+                    join_date DATE NOT NULL,
+                    weekly_playtime INT NOT NULL,
+                    available_days TEXT NOT NULL,
+                    available_times TEXT NOT NULL,
+                    previous_experience TEXT NOT NULL,
+                    plugin_experience TEXT NOT NULL,
+                    moderator_expectations TEXT NOT NULL,
+                    additional_info TEXT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+                    send_at TIMESTAMP NULL,
+                    assigned_to BIGINT UNSIGNED NULL,
+                    FOREIGN KEY (uuid) REFERENCES privileged_users(uuid) ON DELETE CASCADE ON UPDATE CASCADE
+                );
+                """;
+        try (Statement statement = sqlSession.getConnection().createStatement()) {
+            statement.execute(query);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static void createAppealTable(@NotNull SqlSession sqlSession) {
+        String query = """
+                CREATE TABLE IF NOT EXISTS appeals (
+                    id UUID NOT NULL DEFAULT (UUID()) PRIMARY KEY,
+                    uuid UUID NOT NULL,
+                    historyType VARCHAR(16) NOT NULL,
+                    historyId BIGINT UNSIGNED NOT NULL,
+                    username VARCHAR(16) NOT NULL,
+                    reason TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+                    send_at TIMESTAMP NULL,
+                    e_mail TEXT NOT NULL,
+                    assigned_to BIGINT UNSIGNED NULL,
+                    FOREIGN KEY (uuid) REFERENCES privileged_users(uuid) ON DELETE CASCADE ON UPDATE CASCADE
+                );
+                """;
+        try (Statement statement = sqlSession.getConnection().createStatement()) {
+            statement.execute(query);
+        } catch (SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
 }

discord/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+    id("java")
+}
+
+group = "com.alttd.webinterface"
+version = "unspecified"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation(platform("org.junit:junit-bom:5.10.0"))
+    testImplementation("org.junit.jupiter:junit-jupiter")
+    // JDA
+    implementation("net.dv8tion:JDA:6.0.0-rc.2") {
+        exclude("opus-java") // exclude audio
+        exclude("tink") // exclude audio
+    }
+    compileOnly("org.projectlombok:lombok:1.18.38")
+    annotationProcessor("org.projectlombok:lombok:1.18.38")
+}
+
+tasks.test {
+    useJUnitPlatform()
+}

discord/src/main/java/com/alttd/webinterface/DiscordBot.java

@@ -0,0 +1,18 @@
+package com.alttd.webinterface;
+
+import com.alttd.webinterface.bot.DiscordBotInstance;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class DiscordBot {
+
+    public static void main(String[] args) {
+        String discordToken = System.getProperty("DISCORD_TOKEN");
+        if (discordToken == null) {
+            log.error("Discord token not found, put it in the DISCORD_TOKEN environment variable");
+            System.exit(1);
+        }
+        DiscordBotInstance discordBotInstance = new DiscordBotInstance();
+        discordBotInstance.start(discordToken);
+    }
+}

discord/src/main/java/com/alttd/webinterface/bot/DiscordBotInstance.java

@@ -0,0 +1,34 @@
+package com.alttd.webinterface.bot;
+
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.JDA;
+import net.dv8tion.jda.api.JDABuilder;
+import net.dv8tion.jda.api.requests.GatewayIntent;
+
+@Slf4j
+public class DiscordBotInstance {
+
+    @Getter
+    private JDA jda;
+    private volatile boolean ready = false;
+
+    public synchronized void start(String token) {
+        if (jda != null) {
+            return;
+        }
+        jda = JDABuilder.createDefault(token,
+                GatewayIntent.GUILD_MEMBERS,
+                GatewayIntent.GUILD_PRESENCES,
+                GatewayIntent.GUILD_MESSAGES,
+                GatewayIntent.MESSAGE_CONTENT)
+                .addEventListeners(new ReadyListener(() -> {
+                    ready = true;
+                }))
+                .build();
+    }
+
+    public boolean isReady() {
+        return ready && jda != null && jda.getStatus() == JDA.Status.CONNECTED;
+    }
+}

discord/src/main/java/com/alttd/webinterface/bot/ReadyListener.java

@@ -0,0 +1,26 @@
+package com.alttd.webinterface.bot;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.events.session.ReadyEvent;
+import net.dv8tion.jda.api.hooks.ListenerAdapter;
+import org.jetbrains.annotations.NotNull;
+
+@Slf4j
+@RequiredArgsConstructor
+public class ReadyListener extends ListenerAdapter {
+
+    private final Runnable onReadyCallback;
+
+    @Override
+    public void onReady(@NotNull ReadyEvent event) {
+        log.info("JDA is ready. Guilds loaded: {}", event.getJDA().getGuilds().size());
+        if (onReadyCallback != null) {
+            try {
+                onReadyCallback.run();
+            } catch (Exception e) {
+                log.error("Error running onReady callback", e);
+            }
+        }
+    }
+}

discord/src/main/java/com/alttd/webinterface/send_message/DiscordSender.java

@@ -0,0 +1,133 @@
+package com.alttd.webinterface.send_message;
+
+import com.alttd.webinterface.bot.DiscordBotInstance;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.MessageEmbed;
+import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
+
+import java.awt.*;
+import java.time.Instant;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+@Slf4j
+public class DiscordSender {
+
+    private static final DiscordSender INSTANCE = new DiscordSender();
+
+    private final DiscordBotInstance botInstance = new DiscordBotInstance();
+
+    private DiscordSender() {}
+
+    public static DiscordSender getInstance() {
+        return INSTANCE;
+    }
+
+    private void ensureStarted() {
+        if (botInstance.getJda() != null) return;
+        String token = Optional.ofNullable(System.getenv("DISCORD_TOKEN"))
+                .orElse(System.getProperty("DISCORD_TOKEN"));
+        if (token == null || token.isBlank()) {
+            log.error("Discord token not found. Set DISCORD_TOKEN as an environment variable or system property.");
+            return;
+        }
+        botInstance.start(token);
+    }
+
+    public void sendMessageToChannels(List<Long> channelIds, String message) {
+        ensureStarted();
+        if (botInstance.getJda() == null) {
+            log.error("JDA not initialized; cannot send Discord message.");
+            return;
+        }
+        try {
+            if (!botInstance.isReady()) {
+                botInstance.getJda().awaitReady();
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+            log.warn("Error while waiting for JDA ready state", e);
+        }
+
+        channelIds.stream()
+                .filter(Objects::nonNull)
+                .forEach(id -> {
+                    TextChannel channel = botInstance.getJda().getChannelById(TextChannel.class, id);
+                    if (channel == null) {
+                        log.warn("TextChannel with id {} not found", id);
+                        return;
+                    }
+                    channel.sendMessage(message).queue(
+                            success -> log.debug("Sent message to channel {}", id),
+                            error -> log.error("Failed sending message to channel {}", id, error)
+                    );
+                });
+    }
+
+    public void sendEmbedToChannels(List<Long> channelIds, String title, String description, List<EmbedField> fields,
+                                    Integer colorRgb, Instant timestamp, String footer) {
+        ensureStarted();
+        if (botInstance.getJda() == null) {
+            log.error("JDA not initialized; cannot send Discord embed.");
+            return;
+        }
+        try {
+            if (!botInstance.isReady()) {
+                botInstance.getJda().awaitReady();
+            }
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } catch (Exception e) {
+            log.warn("Error while waiting for JDA ready state", e);
+        }
+
+        EmbedBuilder eb = new EmbedBuilder();
+        if (title != null && !title.isBlank()) eb.setTitle(title);
+        if (description != null && !description.isBlank()) eb.setDescription(description);
+        if (colorRgb != null) eb.setColor(new Color(colorRgb)); else eb.setColor(new Color(0xFF8C00)); // default orange
+        eb.setTimestamp(timestamp != null ? timestamp : Instant.now());
+        if (footer != null && !footer.isBlank()) eb.setFooter(footer);
+
+        if (fields != null) {
+            for (EmbedField f : fields) {
+                if (f == null) continue;
+                String name = f.getName() == null ? "" : f.getName();
+                String value = f.getValue() == null ? "" : f.getValue();
+                // JDA field value max is 1024; truncate to be safe
+                if (value.length() > 1024) value = value.substring(0, 1021) + "...";
+                eb.addField(new MessageEmbed.Field(name, value, f.isInline()));
+            }
+        }
+
+        MessageEmbed embed = eb.build();
+
+        channelIds.stream()
+                .filter(Objects::nonNull)
+                .forEach(id -> {
+                    TextChannel channel = botInstance.getJda().getChannelById(TextChannel.class, id);
+                    if (channel == null) {
+                        log.warn("TextChannel with id {} not found", id);
+                        return;
+                    }
+                    channel.sendMessageEmbeds(embed).queue(
+                            success -> log.debug("Sent embed to channel {}", id),
+                            error -> log.error("Failed sending embed to channel {}", id, error)
+                    );
+                });
+    }
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class EmbedField {
+        private String name;
+        private String value;
+        private boolean inline;
+    }
+}

frontend/angular.json

@@ -15,11 +15,12 @@
       "prefix": "app",
       "architect": {
         "build": {
-          "builder": "@angular-devkit/build-angular:browser",
+          "builder": "@angular/build:application",
           "options": {
-            "outputPath": "dist",
+            "outputPath": {
+              "base": "dist"
+            },
             "index": "src/index.html",
-            "main": "src/main.ts",
             "polyfills": [
               "zone.js"
             ],
@@ -34,7 +35,8 @@
             "styles": [
               "src/styles.scss"
             ],
-            "scripts": []
+            "scripts": [],
+            "browser": "src/main.ts"
           },
           "configurations": {
             "production": {
@@ -47,9 +49,7 @@
               "optimization": true,
               "outputHashing": "all",
               "sourceMap": false,
-              "namedChunks": false,
-              "vendorChunk": false,
-              "buildOptimizer": true
+              "namedChunks": false
             },
             "development": {
               "sourceMap": true,
@@ -71,14 +71,15 @@
               "optimization": true,
               "outputHashing": "all",
               "sourceMap": false,
-              "namedChunks": false,
-              "vendorChunk": false,
-              "buildOptimizer": true
+              "namedChunks": false
             }
           }
         },
         "serve": {
-          "builder": "@angular-devkit/build-angular:dev-server",
+          "options": {
+            "proxyConfig": "proxy.conf.json"
+          },
+          "builder": "@angular/build:dev-server",
           "configurations": {
             "production": {
               "buildTarget": "frontend:build:production"
@@ -90,10 +91,10 @@
           "defaultConfiguration": "development"
         },
         "extract-i18n": {
-          "builder": "@angular-devkit/build-angular:extract-i18n"
+          "builder": "@angular/build:extract-i18n"
         },
         "test": {
-          "builder": "@angular-devkit/build-angular:karma",
+          "builder": "@angular/build:karma",
           "options": {
             "polyfills": [
               "zone.js",
@@ -119,5 +120,31 @@
   },
   "cli": {
     "analytics": false
+  },
+  "schematics": {
+    "@schematics/angular:component": {
+      "type": "component"
+    },
+    "@schematics/angular:directive": {
+      "type": "directive"
+    },
+    "@schematics/angular:service": {
+      "type": "service"
+    },
+    "@schematics/angular:guard": {
+      "typeSeparator": "."
+    },
+    "@schematics/angular:interceptor": {
+      "typeSeparator": "."
+    },
+    "@schematics/angular:module": {
+      "typeSeparator": "."
+    },
+    "@schematics/angular:pipe": {
+      "typeSeparator": "."
+    },
+    "@schematics/angular:resolver": {
+      "typeSeparator": "."
+    }
   }
 }

frontend/build.gradle.kts

@@ -8,8 +8,9 @@ plugins {
 
 node {
   download.set(true)
-  version.set("22.14.0")
-  npmVersion.set("10.9.2")
+  // Update to the version that's compatible with your environment requirements
+  version.set("20.19.0")
+  npmVersion.set("10.2.3") // A compatible npm version for Node.js 20.19.0
   workDir.set(file("${project.projectDir}/node"))
   npmWorkDir.set(file("${project.projectDir}/node"))
 }
@@ -21,38 +22,37 @@ tasks.register<Delete>("cleanDist") {
 }
 
 // Create a task that will run npm build
-tasks.register("npmBuild") {
+tasks.register<com.github.gradle.node.npm.task.NpmTask>("npmBuild") {
   description = "Run 'npm run build'"
   group = "build"
 
-  doLast {
-    // Use nodeCommand directly from the plugin
-    project.exec {
-      workingDir(project.projectDir)
-
-      // Use node's npm to ensure it works on all environments
-      val nodeDir = "${project.projectDir}/node"
+  // Determine which build script to run based on the OS
   val isWindows = System.getProperty("os.name").lowercase().contains("windows")
-
-      if (isWindows) {
-        val npmCmd = file(nodeDir).listFiles()?.find { it.name.startsWith("npm") && it.isDirectory }?.let {
-          "${it.absolutePath}/npm.cmd"
-        } ?: "$nodeDir/node_modules/npm/bin/npm.cmd"
-
-        commandLine(npmCmd, "run", "build:dev")
-      } else {
-        val npmExecutable = file(nodeDir).listFiles()?.find { it.name.startsWith("npm") && it.isDirectory }?.let {
-          "${it.absolutePath}/bin/npm"
-        } ?: "$nodeDir/node_modules/npm/bin/npm"
-
-        commandLine(npmExecutable, "run", "build:beta")
-      }
-    }
-  }
+  npmCommand.set(listOf("run", if (isWindows) "build:dev" else "build:beta"))
 
   dependsOn("npmInstall")
 }
 
+// Add a new task to check Node.js and npm versions
+tasks.register<com.github.gradle.node.task.NodeTask>("nodeVersionCheck") {
+  description = "Check Node.js and npm versions"
+  script.set(file("${projectDir}/node-version-check.js"))
+
+  doFirst {
+    // Create a temporary script to check versions
+    file("${projectDir}/node-version-check.js").writeText("""
+      console.log('Node.js version:', process.version);
+      console.log('npm version:', require('npm/package.json').version);
+      console.log('Build command that would be used:', process.platform === 'win32' ? 'build:dev' : 'build:beta');
+    """.trimIndent())
+  }
+
+  doLast {
+    // Clean up the temporary script
+    delete("${projectDir}/node-version-check.js")
+  }
+}
+
 tasks.named("assemble") {
   dependsOn("npmBuild")
 }

frontend/package.json

@@ -13,27 +13,27 @@
   },
   "private": true,
   "dependencies": {
-    "@angular/cdk": "^19.2.18",
-    "@angular/common": "^19.2.0",
-    "@angular/compiler": "^19.2.0",
-    "@angular/core": "^19.2.0",
-    "@angular/forms": "^19.2.0",
-    "@angular/material": "^19.2.18",
-    "@angular/platform-browser": "^19.2.0",
-    "@angular/platform-browser-dynamic": "^19.2.0",
-    "@angular/router": "^19.2.0",
+    "@angular/cdk": "^20.1.3",
+    "@angular/common": "^20.1.0",
+    "@angular/compiler": "^20.1.0",
+    "@angular/core": "^20.1.0",
+    "@angular/forms": "^20.1.0",
+    "@angular/material": "^20.1.3",
+    "@angular/platform-browser": "^20.1.0",
+    "@angular/platform-browser-dynamic": "^20.1.0",
+    "@angular/router": "^20.1.0",
     "@auth0/angular-jwt": "^5.2.0",
     "@types/three": "^0.177.0",
-    "ngx-cookie-service": "^19.1.2",
+    "ngx-cookie-service": "^20.0.1",
     "rxjs": "~7.8.0",
     "three": "^0.177.0",
     "tslib": "^2.3.0",
     "zone.js": "~0.15.0"
   },
   "devDependencies": {
-    "@angular-devkit/build-angular": "^19.2.5",
-    "@angular/cli": "^19.2.5",
-    "@angular/compiler-cli": "^19.2.0",
+    "@angular/build": "^20.1.0",
+    "@angular/cli": "^20.1.0",
+    "@angular/compiler-cli": "^20.1.0",
     "@types/jasmine": "~5.1.0",
     "jasmine-core": "~5.6.0",
     "karma": "~6.4.0",
@@ -41,6 +41,6 @@
     "karma-coverage": "~2.2.0",
     "karma-jasmine": "~5.1.0",
     "karma-jasmine-html-reporter": "~2.1.0",
-    "typescript": "~5.7.2"
+    "typescript": "^5.8.3"
   }
 }

frontend/proxy.conf.json

@@ -0,0 +1,7 @@
+{
+  "/api": {
+    "target": "http://localhost:8080",
+    "secure": false,
+    "changeOrigin": true
+  }
+}

frontend/src/app/app.config.ts

@@ -1,26 +0,0 @@
-import {ApplicationConfig, provideZoneChangeDetection} from '@angular/core';
-import {provideRouter} from '@angular/router';
-import {JwtHelperService, JwtModule} from '@auth0/angular-jwt';
-import {CookieService} from 'ngx-cookie-service';
-
-import {routes} from './app.routes';
-
-// Function to get the JWT token from cookies
-export function jwtTokenGetter() {
-  const cookieService = new CookieService(document, null);
-  return cookieService.check('jwt') ? cookieService.get('jwt') : null;
-}
-
-export const appConfig: ApplicationConfig = {
-  providers: [
-    provideZoneChangeDetection({eventCoalescing: true}),
-    provideRouter(routes),
-    { provide: CookieService, useClass: CookieService },
-    { provide: JwtHelperService, useClass: JwtHelperService },
-    { provide: JwtModule, useValue: JwtModule.forRoot({
-      config: {
-        tokenGetter: jwtTokenGetter
-      }
-    })}
-  ]
-};

frontend/src/app/app.routes.ts

@@ -1,4 +1,5 @@
 import {Routes} from '@angular/router';
+import {AuthGuard} from './guards/auth.guard';
 
 export const routes: Routes = [
   {
@@ -7,7 +8,11 @@ export const routes: Routes = [
   },
   {
     path: 'particles',
-    loadComponent: () => import('./pages/particles/particles.component').then(m => m.ParticlesComponent)
+    loadComponent: () => import('./pages/particles/particles.component').then(m => m.ParticlesComponent),
+    canActivate: [AuthGuard],
+    data: {
+      requiredAuthorizations: ['SCOPE_head_mod']
+    }
   },
   {
     path: 'map',
@@ -102,11 +107,53 @@ export const routes: Routes = [
     loadComponent: () => import('./pages/reference/staffpowers/staffpowers.component').then(m => m.StaffpowersComponent)
   },
   {
-    path: 'forms/:form',
+    path: 'forms',
     loadComponent: () => import('./pages/forms/forms.component').then(m => m.FormsComponent)
   },
   {
-    path: 'forms',
-    loadComponent: () => import('./pages/forms/forms.component').then(m => m.FormsComponent)
+    path: 'appeal',
+    redirectTo: 'forms/appeal',
+    pathMatch: 'full'
+  },
+  {
+    path: 'forms/appeal',
+    loadComponent: () => import('./pages/forms/appeal/appeal.component').then(m => m.AppealComponent),
+    canActivate: [AuthGuard],
+    data: {
+      requiredAuthorizations: ['SCOPE_user']
     }
+  },
+  {
+    path: 'forms/sent',
+    loadComponent: () => import('./pages/forms/sent/sent.component').then(m => m.SentComponent),
+    canActivate: [AuthGuard],
+    data: {
+      requiredAuthorizations: ['SCOPE_user']
+    }
+  },
+  {
+    path: 'apply',
+    redirectTo: 'forms/staff-application',
+    pathMatch: 'full'
+  },
+  {
+    path: 'forms/staff-application',
+    loadComponent: () => import('./pages/forms/staff-application/staff-application.component').then(m => m.StaffApplicationComponent),
+    canActivate: [AuthGuard],
+    data: {
+      requiredAuthorizations: ['SCOPE_user']
+    }
+  },
+  {
+    path: 'community',
+    loadComponent: () => import('./pages/altitude/community/community.component').then(m => m.CommunityComponent)
+  },
+  {
+    path: 'nicknames',
+    loadComponent: () => import('./pages/reference/nicknames/nicknames.component').then(m => m.NicknamesComponent)
+  },
+  {
+    path: 'nickgenerator',
+    loadComponent: () => import('./pages/reference/nickgenerator/nickgenerator.component').then(m => m.NickgeneratorComponent)
+  },
 ];

frontend/src/app/guards/auth.guard.ts

@@ -0,0 +1,54 @@
+import {Injectable} from '@angular/core';
+import {ActivatedRouteSnapshot, CanActivate, Router, RouterStateSnapshot, UrlTree} from '@angular/router';
+import {map, Observable} from 'rxjs';
+import {AuthService} from '@services/auth.service';
+import {MatDialog} from '@angular/material/dialog';
+import {LoginDialogComponent} from '@shared-components/login/login.component';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AuthGuard implements CanActivate {
+
+  constructor(
+    private authService: AuthService,
+    private router: Router,
+    private dialog: MatDialog
+  ) {
+  }
+
+  canActivate(
+    route: ActivatedRouteSnapshot,
+    state: RouterStateSnapshot
+  ): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {
+    if (!this.authService.isAuthenticated$()) {
+      this.router.createUrlTree(['/']);
+      const dialogRef = this.dialog.open(LoginDialogComponent, {
+        width: '400px',
+      })
+      return dialogRef.afterClosed().pipe(
+        map(result => {
+          if (result) {
+            return this.router.createUrlTree([state.url]);
+          }
+          return this.router.createUrlTree(['/']);
+        })
+      );
+    }
+
+    const requiredAuthorizations = route.data['requiredAuthorizations'] as string[];
+
+    if (!requiredAuthorizations || requiredAuthorizations.length === 0) {
+      return true;
+    }
+
+    const userAuthorizations = this.authService.getUserAuthorizations();
+    const hasAccess = requiredAuthorizations.some(auth => userAuthorizations.includes(auth));
+
+    if (!hasAccess) {
+      return this.router.createUrlTree(['/']);
+    }
+
+    return true;
+  }
+}

frontend/src/app/pages/altitude/about/about.component.ts

@@ -1,13 +1,12 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
-import {CommonModule} from '@angular/common';
+
 import {HeaderComponent} from '@header/header.component';
 
 @Component({
   selector: 'app-about',
   standalone: true,
   imports: [
-    CommonModule,
     HeaderComponent
 ],
   templateUrl: './about.component.html',

frontend/src/app/pages/altitude/birthdays/birthdays.component.ts

@@ -1,13 +1,12 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
-import {CommonModule} from '@angular/common';
+
 import {HeaderComponent} from '@header/header.component';
 
 @Component({
   selector: 'app-birthdays',
   standalone: true,
   imports: [
-    CommonModule,
     HeaderComponent
 ],
   templateUrl: './birthdays.component.html',

frontend/src/app/pages/altitude/community/community.component.html

@@ -0,0 +1,79 @@
+<ng-container>
+  <app-header [current_page]="'community'" height="460px" background_image="/public/img/backgrounds/community.jpg"
+              [overlay_gradient]="0.5">
+    <div class="title" header-content>
+      <h1>Community</h1>
+      <h2>Talented people who help Altitude in more than one way.</h2>
+    </div>
+  </app-header>
+
+  <main>
+    <section class="darkmodeSection">
+      <div class="customContainer">
+        <h2>Current Nitro Boosters</h2>
+      </div>
+    </section>
+    <section id="social" class="darkmodeSectionThree">
+      <div class="container" style="padding: 50px 0 0 0; justify-content: center;">
+        <h2 class="sectionTitle">Social Media</h2>
+      </div>
+      <div style="display: flex; justify-content: center; padding-bottom: 30px;">
+        <p style="text-align: center;">We're currently not looking for more people to help manage our socials.</p>
+      </div>
+    </section>
+    <section id="crateTeam" class="darkmodeSection">
+      <div class="container" style="padding: 50px 0 0 0; justify-content: center;">
+        <h2 class="sectionTitle">Crate Team</h2>
+      </div>
+    </section>
+    <section class="darkmodeSectionThree">
+      <div class="container" style="padding: 50px 0 0 0; justify-content: center;">
+        <h2 class="sectionTitle">Event Leaders</h2>
+      </div>
+      <div style="display: flex; justify-content: center; padding-bottom: 30px;">
+        <p style="text-align: center;">We're currently not looking for more Event Leaders.</p>
+      </div>
+    </section>
+    <section class="darkmodeSection">
+      <div class="container" style="padding: 50px 0 0 0; justify-content: center;">
+        <h2 class="sectionTitle">Event Team</h2>
+      </div>
+      <div style="display: flex; justify-content: center; padding-bottom: 30px;">
+        <div style="flex-direction: column;">
+          <p style="text-align: center;">We occasionally open applications for the event team.</p>
+          <p style="text-align: center;">If you're interested in joining you simply need to keep an eye on the Discord
+            announcements.</p>
+        </div>
+      </div>
+    </section>
+    <section class="darkmodeSectionThree">
+      <div class="container" style="padding: 50px 0 0 0; justify-content: center;">
+        <h2 class="sectionTitle">YouTubers & Streamers</h2>
+      </div>
+      <div style="display: flex; justify-content: center; padding-bottom: 30px;">
+        <div style="flex-direction: column;">
+          <p style="text-align: center;"><a style="cursor: pointer;" id="reqButton">Show Requirements...</a></p>
+        </div>
+      </div>
+      <div id="req" class="hide" style="display: flex; justify-content: center; padding-bottom: 30px;">
+        <div style="flex-direction: column; justify-content: center; max-width: 800px;">
+          <p style="text-align: center;"><span style="font-family: 'opensans-bold', sans-serif;">Requirements:</span>
+          </p>
+          <p style="text-align: center;">You need to have at least one recent stream/video on Altitude which we can use
+            to gauge if your audience enjoys your content on Altitude.</p>
+          <br>
+          <p style="text-align: center;">Twitch: You need to be affiliate and get at least 5 viewers on average while
+            streaming on Altitude.</p>
+          <p style="text-align: center;">YouTube videos: You need at least 500 subs and have at least 200 views per
+            video within a week on average for Altitude content.</p>
+          <p style="text-align: center;">YouTube streamers: You need at least 500 subs and have at least 5 viewers on
+            average while streaming on Altitude.</p>
+          <br>
+          <p style="text-align: center;"><span style="font-family: 'opensans-bold', sans-serif;">Note:</span> Before
+            accepting or denying you we will watch your latest video/stream on Altitude (so keep your broadcasts public
+            on twitch).</p>
+        </div>
+      </div>
+    </section>
+  </main>
+</ng-container>

frontend/src/app/pages/altitude/community/community.component.scss

@@ -0,0 +1,12 @@
+.customContainer {
+  width: 80%;
+  max-width: 1020px;
+  margin: auto;
+  padding: 80px 0;
+  text-align: center;
+}
+
+.hide {
+  display: none !important;
+}
+

frontend/src/app/pages/altitude/community/community.component.spec.ts

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { CommunityComponent } from './community.component';
+
+describe('CommunityComponent', () => {
+  let component: CommunityComponent;
+  let fixture: ComponentFixture<CommunityComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [CommunityComponent]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(CommunityComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/src/app/pages/altitude/community/community.component.ts

@@ -0,0 +1,14 @@
+import {Component} from '@angular/core';
+import {HeaderComponent} from "@header/header.component";
+
+@Component({
+  selector: 'app-community',
+  imports: [
+    HeaderComponent
+  ],
+  templateUrl: './community.component.html',
+  styleUrl: './community.component.scss'
+})
+export class CommunityComponent {
+
+}

frontend/src/app/pages/altitude/socials/socials.component.ts

@@ -1,13 +1,12 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
-import {CommonModule, NgOptimizedImage} from '@angular/common';
+import { NgOptimizedImage } from '@angular/common';
 import {HeaderComponent} from '@header/header.component';
 
 @Component({
   selector: 'app-socials',
   standalone: true,
   imports: [
-    CommonModule,
     HeaderComponent,
     NgOptimizedImage
 ],

frontend/src/app/pages/altitude/team/team.component.html

@@ -12,61 +12,75 @@
     <section class="darkmodeSection">
       <div class="container teamContainer">
         <h2 class="sectionTitle">Management</h2>
-        <div *ngFor="let member of getTeamMembers('owner') | async" class="member">
+        @for (member of getTeamMembers('owner') | async; track member) {
+          <div class="member">
             <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
               height="160" width="160" style="width: 160px;">
               <h2>{{ member.name }}</h2>
               <p>Owner</p>
             </div>
-        <div *ngFor="let member of getTeamMembers('manager') | async" class="member">
+          }
+          @for (member of getTeamMembers('manager') | async; track member) {
+            <div class="member">
               <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
                 height="160" width="160" style="width: 160px;">
                 <h2>{{ member.name }}</h2>
                 <p>Manager</p>
               </div>
+            }
           </div>
         </section>
         <section class="darkmodeSectionThree">
           <div class="container teamContainer">
             <h2 class="sectionTitle">Admins</h2>
-        <div *ngFor="let member of getTeamMembers('admin') | async" class="member">
+            @for (member of getTeamMembers('admin') | async; track member) {
+              <div class="member">
                 <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
                   height="160" width="160" style="width: 160px;">
                   <h2>{{ member.name }}</h2>
                   <p>Admin</p>
                 </div>
+              }
             </div>
           </section>
           <section class="darkmodeSection">
             <div class="container teamContainer">
               <h2 class="sectionTitle">Head Moderators</h2>
-        <div *ngFor="let member of getTeamMembers('headmod') | async" class="member">
+              @for (member of getTeamMembers('headmod') | async; track member) {
+                <div class="member">
                   <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
                     height="160" width="160" style="width: 160px;">
                     <h2>{{ member.name }}</h2>
                     <p>Head Mod</p>
                   </div>
+                }
               </div>
             </section>
             <section class="darkmodeSectionThree">
               <div class="container teamContainer">
                 <h2 class="sectionTitle">Moderators</h2>
-        <div *ngFor="let member of getTeamMembers('moderator') | async" class="member">
+                @for (member of getTeamMembers('moderator') | async; track member) {
+                  <div class="member">
                     <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
                       height="160" width="160" style="width: 160px;">
                       <h2>{{ member.name }}</h2>
                     </div>
+                  }
                 </div>
               </section>
-    <section *ngIf="(getTeamMembers('trainee') | async)?.length  ?? 0 > 0" class="darkmodeSection">
+              @if ((getTeamMembers('trainee') | async)?.length  ?? 0 > 0) {
+                <section class="darkmodeSection">
                   <div class="container teamContainer">
                     <h2 class="sectionTitle">Trainees</h2>
-        <div *ngFor="let member of getTeamMembers('trainee') | async" class="member">
+                    @for (member of getTeamMembers('trainee') | async; track member) {
+                      <div class="member">
                         <img [ngSrc]="getAvatarUrl(member)" alt="{{member.name}}'s Minecraft skin"
                           height="160" width="160" style="width: 160px;">
                           <h2>{{ member.name }}</h2>
                         </div>
+                      }
                     </div>
                   </section>
+                }
               </main>
             </ng-container>

frontend/src/app/pages/altitude/team/team.component.ts

@@ -1,11 +1,10 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
-import {BASE_PATH, Player, TeamService} from '@api';
+import {Player, TeamService} from '@api';
 import {CommonModule, NgOptimizedImage} from '@angular/common';
 import {HeaderComponent} from '@header/header.component';
 import {CookieService} from 'ngx-cookie-service';
 import {map, Observable, shareReplay} from 'rxjs';
-import {environment} from '@environment';
 
 @Component({
   selector: 'app-team',
@@ -17,7 +16,6 @@ import {environment} from '@environment';
   ],
   providers: [
     CookieService,
-    {provide: BASE_PATH, useValue: environment.apiUrl}
   ],
 
   templateUrl: './team.component.html',

frontend/src/app/pages/features/claiming/claiming.component.html

@@ -19,8 +19,8 @@
             <p>To claim land, you will need some basic tools: a golden shovel, and a stick. You can craft these items
               yourself or do <b>/claim</b> to receive them for free. The shovel is used for modifying claims and the
               stick is used for viewing claim information.</p>
-            <img ngSrc="/public/img/items/shovel.png" alt="Minecraft golden shovel" style="width: 25%;" height="114"
-                 width="114">
+            <img ngSrc="/public/img/items/shovel.png" alt="Minecraft golden shovel"
+                 class="shovelClaiming" style="width: 25%;" height="114" width="114">
             <p>Players start with an allowance of 500 “claim blocks” and can purchase additional “claim blocks” with
               in-game currency using <span style="font-family: 'opensans-bold', sans-serif;">/buyclaimblocks</span>. How
               many claims you can create depends on the rank you have - the amount can be found on the <a

frontend/src/app/pages/features/claiming/claiming.component.scss

@@ -7,3 +7,10 @@ main li {
   margin-left: 30px;
   padding-bottom: 10px;
 }
+
+
+@media (max-width: 690px) {
+  .shovelClaiming {
+    height: 100px;
+  }
+}

frontend/src/app/pages/features/customfeatures/customfeatures.component.html

@@ -163,7 +163,6 @@
           <div class="columnParagraph">
             <h2>Miscellaneous</h2>
             <p>Grindstones can strip shulker box & beehive NBT data</p>
-            <p>Sneak click mending</p>
             <p>/iwanttobreakthisblock, required to break some natural generated blocks</p>
             <p>/sneakclickmending, allows you to mend your items by right clicking while sneaking</p>
             <p>Swift Sneak enchantment can be found in villager trades</p>

frontend/src/app/pages/features/customfeatures/customfeatures.component.scss

@@ -7,3 +7,9 @@ main li {
   margin-left: 30px;
   padding-bottom: 10px;
 }
+
+@media (max-width: 690px) {
+  .columnContainer {
+    text-align: left !important;
+  }
+}

frontend/src/app/pages/features/economy/economy.component.html

@@ -104,7 +104,7 @@
               prices will become more and more extreme. You can see where these thresholds are based on your current
               points here:</p>
             <img ngSrc="/public/img/random/pointbracket.png" alt="Visualization of the point bracket."
-                 style="width: 100%; padding: 0 0 15px 0;"
+                 class="visEconomy" style="width: 100%; padding: 0 0 15px 0;"
                  height="100" width="800">
           </div>
           <div class="columnParagraph">

frontend/src/app/pages/features/economy/economy.component.scss

@@ -7,3 +7,19 @@ main li {
   margin-left: 30px;
   padding-bottom: 10px;
 }
+
+@media (max-width: 690px) {
+  .title {
+    height: calc(100% - 110px);
+    margin-top: 100px;
+  }
+
+  .title h2 {
+    font-size: 0.9em;
+  }
+
+  .visEconomy {
+    height: 50px;
+    width: 357px;
+  }
+}

frontend/src/app/pages/features/map/map.component.html

@@ -6,9 +6,9 @@
       <h1>Dynamic Server Maps</h1>
       <h2>Which server would you like to see?</h2>
       <div>
-        <a href="https://gmap.alttd.com">
+        <a href="https://bmap.alttd.com">
           <div style="background-color: #F547B2;" class="button-outer map-button">
-            <span class="button-inner">Grove</span>
+            <span class="button-inner">Bayou</span>
           </div>
         </a>
         <a href="https://cmap.alttd.com">

frontend/src/app/pages/features/map/map.component.scss

@@ -11,3 +11,13 @@
   padding-bottom: 25px;
   font-weight: 100;
 }
+
+@media (max-width: 670px) {
+  .title h1 {
+    font-size: 2em;
+  }
+
+  .title h2 {
+    font-size: 1em;
+  }
+}

frontend/src/app/pages/features/map/map.component.ts

@@ -1,11 +1,10 @@
 import {Component} from '@angular/core';
-import {CommonModule} from '@angular/common';
+
 import {HeaderComponent} from '@header/header.component';
 
 @Component({
   standalone: true,
   imports: [
-    CommonModule,
     HeaderComponent
 ],
   selector: 'app-map',

frontend/src/app/pages/features/mypet/mypet.component.html

@@ -24,8 +24,8 @@
               your other pets while they are in storage. To interact with your MyPet you will need to make it your
               active MyPet by doing <span style="font-family: 'opensans-bold', sans-serif;">/petswitch</span> and
               selecting the one you want to use.</p>
-            <img ngSrc="/public/img/items/lead.png" alt="Minecraft lead/leash" style="width: 20%;" height="96"
-                 width="96">
+            <img ngSrc="/public/img/items/lead.png" alt="Minecraft lead/leash"
+                 class="leadMyPet" style="width: 20%;" height="96" width="96">
           </div>
           <div class="columnParagraph">
             <h2>Skilltrees and Levels</h2>

frontend/src/app/pages/features/mypet/mypet.component.scss

@@ -13,3 +13,9 @@ main li {
   justify-content: space-between;
   flex-wrap: wrap;
 }
+
+@media (max-width: 690px) {
+  .leadMyPet {
+    height: 70px;
+  }
+}

frontend/src/app/pages/features/warps/warps.component.html

@@ -19,10 +19,8 @@
               name, description, and icon) on their own! This lets you easily promote your town, shop, farm, or just
               about anything else.</p>
             <p>All warps are separated into categories so it's easy to find the category of warp you're looking for.</p>
-            <img ngSrc="/public/img/random/warpgui.png"
-                 alt="In-game warp GUI"
-                 style="width: 80%; padding-bottom: 15px;"
-                 height="232" width="356">
+            <img ngSrc="/public/img/random/warpgui.png" alt="In-game warp GUI"
+                 class="guiWarp" style="width: 80%; padding-bottom: 15px;" height="232" width="356">
           </div>
         </div>
         <div class="columnContainer">
@@ -45,7 +43,7 @@
         </div>
       </section>
       <section class="columnSection" style="padding-top: 0;">
-        <div class="columnParagraph" style="padding-left: 15px;">
+        <div class="columnParagraph" style="padding-left: 15px; text-align: center;">
           <h2>Warp Requirements</h2>
           <p>You need to be the owner of the claim your warp is placed in. It should look good, and be as finished as
             your warp type allows you to have it. Safety is an important aspect as well, visitors should not be
@@ -207,10 +205,8 @@
               warp, just do <span style="font-family: 'opensans-bold', sans-serif;">/warps</span> and click on the chest
               labeled "<span style="font-family: 'opensans-bold', sans-serif;">My Warps</span>" in the bottom left
               corner.</p>
-            <img ngSrc="/public/img/random/editwarpgui.png"
-                 alt="In-game warp edit GUI"
-                 style="width: 80%;"
-                 width="384" height="170">
+            <img ngSrc="/public/img/random/editwarpgui.png" alt="In-game warp edit GUI"
+                 class="editWarp" style="width: 80%;" width="384" height="170">
             <p>Maintaining a warp also involves making sure it looks nice, shops are well stocked, and, if it's a town,
               open plots are always available for residents to move in. Make sure you keep up on maintaining your warp
               or it could be deleted! If a warp is deleted by a staff member you will not receive a refund for the

frontend/src/app/pages/features/warps/warps.component.scss

@@ -12,3 +12,13 @@ main li {
   color: var(--font-color);
   transition: 0.5s ease;
 }
+
+@media (max-width: 690px) {
+  .guiWarp {
+    height: 190px;
+  }
+
+  .editWarp {
+    height: 130px;
+  }
+}

frontend/src/app/pages/footer/footer/footer.component.html

@@ -3,12 +3,12 @@
     <div class="footerInner">
       <div class="footerText">
         <h2>ABOUT US</h2>
-        <p>​Altitude is a community-centered {{ ALTITUDE_VERSION }} survival server. We're one of those servers you come
+        <p>Altitude is a community-centered {{ ALTITUDE_VERSION }} survival server. We're one of those servers you come
           to call "home". We are your place to get together with friends and play survival, with a few extra features
           suggested by our community!</p>
         <div class="followUs" style="height: 35px; display: flex; align-items: flex-end;">
           <a target="_blank" rel="noopener" href="https://discordapp.com/invite/TGqpzCJ">
-            <img ngSrc="/public/img/logos/discord.png" alt="Discord Button" height="32" width="32">
+            <img priority ngSrc="/public/img/logos/discord.png" alt="Discord Button" height="32" width="32">
           </a>
           <a target="_blank" rel="noopener" href="https://twitter.com/alttdmc">
             <img ngSrc="/public/img/logos/twitter.png" alt="Twitter Button" height="32" width="32">

frontend/src/app/pages/footer/footer/footer.component.scss

@@ -67,3 +67,40 @@ footer ul, footer p {
 .copyright {
   margin-top: 50px;
 }
+
+@media (max-width: 1150px) {
+  .footerInner {
+    flex-wrap: wrap;
+    text-align: center;
+  }
+
+  .footerText {
+    flex: 1 1 100%;
+    margin-right: 0;
+    margin-bottom: 30px;
+  }
+
+  .footerNav {
+    border-left: none;
+    padding-left: 0px;
+    padding-bottom: 15px;
+    min-width: 200px;
+  }
+
+  .followUs {
+    width: 100px;
+    margin: 0 auto;
+  }
+
+  .footerNav {
+    border-left: none;
+    padding-left: 0px;
+    padding-bottom: 15px;
+    min-width: 200px;
+  }
+
+  .copyright {
+    margin-top: 30px;
+    text-align: center;
+  }
+}

frontend/src/app/pages/footer/footer/footer.component.ts

@@ -1,13 +1,12 @@
 import {Component} from '@angular/core';
 import {ALTITUDE_VERSION} from '@custom-types/constant';
-import {CommonModule, NgOptimizedImage} from '@angular/common';
+import { NgOptimizedImage } from '@angular/common';
 import {RouterLink} from '@angular/router';
 
 @Component({
   selector: 'app-footer',
   standalone: true,
   imports: [
-    CommonModule,
     RouterLink,
     NgOptimizedImage
 ],

frontend/src/app/pages/footer/privacy/privacy.component.ts

@@ -1,6 +1,6 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
-import {CommonModule} from '@angular/common';
+
 import {HeaderComponent} from '@header/header.component';
 import {RouterLink} from '@angular/router';
 
@@ -8,7 +8,6 @@ import {RouterLink} from '@angular/router';
   selector: 'app-privacy',
   standalone: true,
   imports: [
-    CommonModule,
     HeaderComponent,
     RouterLink
 ],

frontend/src/app/pages/footer/terms/terms.component.ts

@@ -1,7 +1,7 @@
 import {Component} from '@angular/core';
 import {ScrollService} from '@services/scroll.service';
 import {HeaderComponent} from '@header/header.component';
-import {CommonModule} from '@angular/common';
+
 import {RouterLink} from '@angular/router';
 
 @Component({
@@ -9,7 +9,6 @@ import {RouterLink} from '@angular/router';
   standalone: true,
   templateUrl: './terms.component.html',
   imports: [
-    CommonModule,
     HeaderComponent,
     RouterLink
 ],

frontend/src/app/pages/forms/appeal/appeal.component.html

@@ -1,5 +1,161 @@
-<app-forms [currentPage]="'appeal'" [formTitle]="'Minecraft Appeal'">
-  <div form-content>
-
+<div>
+  <app-header [current_page]="'appeal'" height="200px" background_image="/public/img/backgrounds/staff.png"
+              [overlay_gradient]="0.5">
+    <div class="title" header-content>
+      <h1>Appeal</h1>
+    </div>
+  </app-header>
+  <main>
+    <section class="darkmodeSection appeal-container">
+      <div class="form-container">
+        <div class="pages">
+          @if (currentPageIndex === 0) {
+            @if (history()?.length === 0) {
+              <section class="formPage">
+                <img ngSrc="/public/img/logos/logo.png" alt="Discord" height="319" width="550"/>
+                <h1>Punishment Appeal</h1>
+                <p>You have no punishments to appeal.</p>
+              </section>
+            } @else {
+              <section class="formPage">
+                <img ngSrc="/public/img/logos/logo.png" alt="Discord" height="319" width="550"/>
+                <h1>Punishment Appeal</h1>
+                <p>We aim to respond within 48 hours.</p>
+                <button mat-raised-button (click)="nextPage()" [disabled]="history() == null">
+                  @if (history() == null) {
+                    <mat-spinner></mat-spinner>
+                  } @else {
+                    Next
+                  }
+                </button>
+              </section>
+            }
+          }
+
+          @if (currentPageIndex === 1) {
+            <section class="formPage">
+              <div class="description">
+                <p>You are logged in as <strong>{{ authService.username() }}</strong>. If this is the correct account
+                  please continue</p>
+                <br>
+                <p><strong>Notice: </strong> Submitting an appeal is <strong>not</strong> an instant process.
+                  We will investigate the punishment you are appealing and respond within 48 hours.</p>
+                <p style="font-style: italic;">Appeals that seem to have been made with
+                  little to no effort will be automatically denied.</p>
+              </div>
+              <button mat-raised-button (click)="nextPage()" [disabled]="authService.username() == null">
+                I, {{ authService.username() }}, understand and agree
+              </button>
+            </section>
+          }
+
+          @if (currentPageIndex === 2) {
+            <section class="formPage">
+              <div class="description">
+                <h2>Please select the punishment you want to appeal</h2>
+              </div>
+              <mat-form-field>
+                <mat-label>Punishment</mat-label>
+                <mat-select (valueChange)="onPunishmentSelected($event)">
+                  @for (punishment of history(); track punishment) {
+                    <mat-option [value]="punishment">{{ punishment.type }} - {{ punishment.reason }}</mat-option>
+                  }
+                </mat-select>
+              </mat-form-field>
+              @if (selectedPunishment() != null) {
+                <button mat-raised-button (click)="nextPage()" [disabled]="selectedPunishment() == null">
+                  Appeal {{ selectedPunishment()!.type }}
+                </button>
+              }
+            </section>
+          }
+
+          <form [formGroup]="form">
+            @if (currentPageIndex === 3) {
+              <section class="formPage">
+                <div class="description">
+                  <h2>Please enter your email.</h2>
+                  <p style="font-style: italic">It does not have to be your minecraft email. You will have to verify
+                    it</p>
+                  <mat-form-field appearance="fill" style="width: 100%;">
+                    <mat-label>Email</mat-label>
+                    <input matInput
+                           formControlName="email"
+                           placeholder="Email">
+                    @if (form.controls.email.invalid && form.controls.email.touched) {
+                      <mat-error>
+                        @if (form.controls.email.errors?.['required']) {
+                          Email is required
+                        } @else if (form.controls.email.errors?.['email']) {
+                          Please enter a valid email address
+                        }
+                      </mat-error>
+                    }
+                  </mat-form-field>
+                  @if (emailIsValid()) {
+                    <div class="valid-email">
+                      <ng-container matSuffix>
+                        <mat-icon>check</mat-icon>
+                        <span>You have validated your email previously, and can continue to the next page!</span>
+                      </ng-container>
+                    </div>
+                  }
+                </div>
+                <button mat-raised-button (click)="validateMailOrNextPage()" [disabled]="form.controls.email.invalid">
+                  Next
+                </button>
+              </section>
+            }
+
+            @if (currentPageIndex === 4) {
+              <section class="formPage">
+                <div class="description">
+                  <h2>Why should your {{ selectedPunishment()?.type }} be reduced or removed?</h2>
+                  <p style="font-style: italic">Please take your time writing this, we're more likely to accept an
+                    appeal if effort was put into it.</p>
+                  <mat-form-field appearance="fill" style="width: 100%;">
+                    <mat-label>Reason</mat-label>
+                    <textarea matInput formControlName="appeal" placeholder="Reason" rows="6"></textarea>
+                    @if (form.controls.appeal.invalid && form.controls.appeal.touched) {
+                      <mat-error>
+                        @if (form.controls.appeal.errors?.['required']) {
+                          Reason is required
+                        } @else if (form.controls.appeal.errors?.['minlength']) {
+                          Reason must be at least 10 characters
+                        }
+                      </mat-error>
+                    }
+                  </mat-form-field>
+                </div>
+                <button mat-raised-button (click)="onSubmit()" [disabled]="form.invalid">
+                  Submit Appeal
+                </button>
+              </section>
+            }
+          </form>
+        </div>
+
+        <!-- Navigation dots -->
+        @if (totalPages.length > 1) {
+          <div class="form-navigation">
+            <button mat-icon-button class="nav-button" (click)="previousPage()" [disabled]="isFirstPage()">
+              <mat-icon>navigate_before</mat-icon>
+            </button>
+
+            @for (i of totalPages; track i) {
+              <div
+                class="nav-dot"
+                [class.active]="i === currentPageIndex"
+                (click)="goToPage(i)">
+              </div>
+            }
+
+            <button mat-icon-button class="nav-button" (click)="nextPage()" [disabled]="isLastPage()">
+              <mat-icon>navigate_next</mat-icon>
+            </button>
+          </div>
+        }
+      </div>
+    </section>
+  </main>
 </div>
-</app-forms>

frontend/src/app/pages/forms/appeal/appeal.component.scss

@@ -0,0 +1,111 @@
+:host {
+  display: block;
+}
+
+.appeal-container {
+  display: flex;
+  flex-direction: column;
+  min-height: 80vh;
+}
+
+main {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+}
+
+.form-container {
+  position: relative;
+  height: 100%;
+  width: 100%;
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+}
+
+.formPage {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+  width: 100%;
+  height: 100%;
+  animation: fadeIn 0.5s ease-in-out;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(20px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+.navigation-buttons {
+  display: flex;
+  gap: 16px;
+  margin-top: 20px;
+}
+
+.form-navigation {
+  display: flex;
+  justify-content: center;
+  gap: 10px;
+  position: absolute;
+  bottom: 0;
+  left: 0;
+  right: 0;
+}
+
+
+.nav-dot {
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  background-color: rgba(255, 255, 255, 0.3);
+  cursor: pointer;
+  transition: background-color 0.3s ease;
+  margin-top: auto;
+  margin-bottom: auto;
+
+  &.active {
+    background-color: #fff;
+  }
+}
+
+.nav-button {
+  color: #1f9bde;
+}
+
+.pages {
+  margin-top: auto;
+  margin-bottom: auto;
+}
+
+.description {
+  max-width: 75ch;
+  text-align: left;
+}
+
+.valid-email {
+  display: flex;
+  align-items: center;
+  color: #4CAF50;
+  margin: 10px 0;
+  padding: 8px 12px;
+  border-radius: 4px;
+  background-color: rgba(76, 175, 80, 0.1);
+}
+
+.valid-email mat-icon {
+  color: #4CAF50;
+  margin-right: 10px;
+}
+
+.valid-email span {
+  color: #4CAF50;
+  font-weight: 500;
+}

frontend/src/app/pages/forms/appeal/appeal.component.ts

@@ -1,30 +1,156 @@
-import {Component, OnInit} from '@angular/core';
-import {FormsComponent} from '../forms.component';
-import {FormControl, FormGroup, Validators} from '@angular/forms';
-import {AppealsService, MinecraftAppeal} from '@api';
+import {
+  AfterViewInit,
+  Component,
+  computed,
+  ElementRef,
+  inject,
+  OnDestroy,
+  OnInit,
+  Renderer2,
+  signal
+} from '@angular/core';
+import {FormControl, FormGroup, ReactiveFormsModule, Validators} from '@angular/forms';
+import {AppealsService, EmailEntry, HistoryService, MailService, MinecraftAppeal, PunishmentHistory} from '@api';
+import {HeaderComponent} from '@header/header.component';
+import {NgOptimizedImage} from '@angular/common';
+import {MatButtonModule} from '@angular/material/button';
+import {MatIconModule} from '@angular/material/icon';
+import {AuthService} from '@services/auth.service';
+import {MatProgressSpinnerModule} from '@angular/material/progress-spinner';
+import {MatFormFieldModule} from '@angular/material/form-field';
+import {MatSelectModule} from '@angular/material/select';
+import {MatInputModule} from '@angular/material/input';
+import {HistoryFormatService} from '@pages/reference/bans/history-format.service';
+import {MatDialog} from '@angular/material/dialog';
+import {VerifyMailDialogComponent} from '@pages/forms/verify-mail-dialog/verify-mail-dialog.component';
+import {Router} from '@angular/router';
 
 @Component({
   selector: 'app-appeal',
   imports: [
-    FormsComponent
+    HeaderComponent,
+    NgOptimizedImage,
+    MatButtonModule,
+    MatIconModule,
+    MatProgressSpinnerModule,
+    MatFormFieldModule,
+    MatSelectModule,
+    MatInputModule,
+    ReactiveFormsModule,
   ],
   templateUrl: './appeal.component.html',
   styleUrl: './appeal.component.scss'
 })
-export class AppealComponent implements OnInit {
+export class AppealComponent implements OnInit, OnDestroy, AfterViewInit {
 
-  public form: FormGroup<Appeal>;
+  private mailService = inject(MailService);
+  private historyFormatService = inject(HistoryFormatService);
+  private appealsService = inject(AppealsService);
+  private historyService = inject(HistoryService);
+  public authService = inject(AuthService);
+  private resizeObserver: ResizeObserver | null = null;
+  private boundHandleResize: any;
 
-  constructor(private appealApi: AppealsService) {
+  protected form: FormGroup<Appeal>;
+  protected history = signal<PunishmentHistory[] | null>(null);
+  protected selectedPunishment = signal<PunishmentHistory | null>(null);
+  private emails = signal<EmailEntry[]>([]);
+  protected verifiedEmails = computed(() => this.emails()
+    .filter(email => email.verified)
+    .map(email => email.email.toLowerCase()));
+  protected emailIsValid = signal<boolean>(false);
+  protected dialog = inject(MatDialog);
+
+  constructor(
+    private elementRef: ElementRef,
+    private renderer: Renderer2
+  ) {
     this.form = new FormGroup({
-      username: new FormControl('', {nonNullable: true, validators: [Validators.required]}),
-      punishmentId: new FormControl('', {nonNullable: true, validators: [Validators.required]}),
       email: new FormControl('', {nonNullable: true, validators: [Validators.required, Validators.email]}),
       appeal: new FormControl('', {nonNullable: true, validators: [Validators.required, Validators.minLength(10)]})
     });
+    this.mailService.getUserEmails().subscribe(emails => {
+      this.emails.set(emails);
+    });
+    this.form.valueChanges.subscribe(() => {
+      if (this.verifiedEmails().includes(this.form.getRawValue().email.toLowerCase())) {
+        this.emailIsValid.set(true);
+      } else {
+        this.emailIsValid.set(false);
+      }
+    });
+    computed(() => {
+      if (this.verifiedEmails().length > 0) {
+        this.form.get('email')?.setValue(this.verifiedEmails()[0]);
+        this.emailIsValid.set(true);
+      }
+    });
   }
 
   ngOnInit() {
+    const uuid = this.authService.getUuid();
+    if (uuid === null) {
+      throw new Error('JWT subject is null, are you logged in?');
+    }
+    this.historyService.getAllHistoryForUUID(uuid).subscribe(history => {
+      this.history.set(history.filter(item => this.historyFormatService.isActive(item)));
+    })
+  }
+
+  ngAfterViewInit() {
+    this.setupResizeObserver();
+    this.updateContainerHeight();
+
+    this.boundHandleResize = this.handleResize.bind(this);
+    window.addEventListener('resize', this.boundHandleResize);
+
+    setTimeout(() => this.updateContainerHeight(), 0);
+  }
+
+  ngOnDestroy() {
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect();
+      this.resizeObserver = null;
+    }
+
+    if (this.boundHandleResize) {
+      window.removeEventListener('resize', this.boundHandleResize);
+    }
+  }
+
+  private handleResize() {
+    this.updateContainerHeight();
+  }
+
+  private setupResizeObserver() {
+    this.resizeObserver = new ResizeObserver(() => {
+      this.updateContainerHeight();
+    });
+
+    const headerElement = document.querySelector('app-header');
+    if (headerElement) {
+      this.resizeObserver.observe(headerElement);
+    }
+
+    const footerElement = document.querySelector('footer');
+    if (footerElement) {
+      this.resizeObserver.observe(footerElement);
+    }
+  }
+
+  private updateContainerHeight() {
+    const headerElement = document.querySelector('app-header');
+    const footerElement = document.querySelector('footer');
+
+    const container = this.elementRef.nativeElement.querySelector('.appeal-container');
+
+    if (headerElement && footerElement && container) {
+      const headerHeight = headerElement.getBoundingClientRect().height;
+      const footerHeight = footerElement.getBoundingClientRect().height;
+
+      const calculatedHeight = `calc(100vh - ${headerHeight}px - ${footerHeight}px)`;
+      this.renderer.setStyle(container, 'min-height', calculatedHeight);
+    }
   }
 
   public onSubmit() {
@@ -35,7 +161,6 @@ export class AppealComponent implements OnInit {
     if (this.form.valid) {
       this.sendForm()
     } else {
-      // Mark all fields as touched to trigger validation display
       Object.keys(this.form.controls).forEach(field => {
         const control = this.form!.get(field);
         if (!(control instanceof FormGroup)) {
@@ -47,23 +172,83 @@ export class AppealComponent implements OnInit {
     }
   }
 
+  private router = inject(Router)
+
   private sendForm() {
     const rawValue = this.form.getRawValue();
+    const uuid = this.authService.getUuid();
+    if (uuid === null) {
+      throw new Error('JWT subject is null, are you logged in?');
+    }
     const appeal: MinecraftAppeal = {
       appeal: rawValue.appeal,
       email: rawValue.email,
-      punishmentId: parseInt(rawValue.punishmentId),
-      username: rawValue.username,
-      uuid: ''//TODO
+      punishmentId: this.selectedPunishment()!.id,
+      punishmentType: this.selectedPunishment()!.type,
+      username: this.authService.username()!,
+      uuid: uuid
     }
-    this.appealApi.submitMinecraftAppeal(appeal).subscribe()
+    this.appealsService.submitMinecraftAppeal(appeal).subscribe((result) => {
+      if (!result.verified_mail) {
+        throw new Error('Mail not verified');
+      }
+      this.router.navigate(['/forms/sent'], {
+        state: {message: result.message}
+      }).then();
+    })
   }
 
+  public currentPageIndex: number = 0;
+  public totalPages: number[] = [0];
+
+  public goToPage(pageIndex: number): void {
+    if (pageIndex >= 0 && pageIndex < this.totalPages.length) {
+      this.currentPageIndex = pageIndex;
+    }
+  }
+
+  public previousPage() {
+    this.goToPage(this.currentPageIndex - 1);
+  }
+
+  public nextPage() {
+    if (this.currentPageIndex === this.totalPages.length - 1) {
+      this.totalPages.push(this.currentPageIndex + 1);
+    }
+    this.goToPage(this.currentPageIndex + 1);
+  }
+
+  public isFirstPage(): boolean {
+    return this.currentPageIndex === 0;
+  }
+
+  public isLastPage(): boolean {
+    return this.currentPageIndex === this.totalPages.length - 1;
+  }
+
+  protected readonly length = length;
+
+  onPunishmentSelected($event: PunishmentHistory) {
+    this.selectedPunishment.set($event);
+  }
+
+  protected validateMailOrNextPage() {
+    if (this.emailIsValid()) {
+      this.nextPage();
+      return;
+    }
+    const dialogRef = this.dialog.open(VerifyMailDialogComponent, {
+      data: {email: this.form.getRawValue().email},
+    });
+    dialogRef.afterClosed().subscribe(result => {
+      if (result === true) {
+        this.emailIsValid.set(true);
+      }
+    });
+  }
 }
 
 interface Appeal {
-  username: FormControl<string>;
-  punishmentId: FormControl<string>;
   email: FormControl<string>;
   appeal: FormControl<string>;
 }

frontend/src/app/pages/forms/forms.component.html

@@ -5,14 +5,28 @@
       <h1>{{ formTitle }}</h1>
     </div>
   </app-header>
-  <ng-container *ngIf="!type">
-    <ng-container *ngFor="let formType of FormType | keyvalue">
-      <button mat-raised-button (click)="setFormType(formType.value)">
-        {{ formType }}
-      </button>
-    </ng-container>
-  </ng-container>
-  <div>
-    <ng-content select="[form-content]"></ng-content>
+  <main>
+    <section class="darkmodeSection">
+      <section class="columnSection">
+        <div class="columnContainer">
+          <div class="columnParagraph">
+            <a [routerLink]="['/forms/appeal']">
+              <h2>Appeal</h2>
+              <p>
+                If you feel your punishment was unjust, click here to appeal.
+              </p>
+            </a>
           </div>
+          <div class="columnParagraph">
+            <a [routerLink]="['/forms/staff-application']">
+              <h2>Staff Application</h2>
+              <p>
+                Interested in becoming a moderator on our server? Apply here.
+              </p>
+            </a>
+          </div>
+        </div>
+      </section>
+    </section>
+  </main>
 </ng-container>

frontend/src/app/pages/forms/forms.component.ts

@@ -1,68 +1,17 @@
-import {Component, Input, OnInit} from '@angular/core';
+import {Component, Input} from '@angular/core';
 import {HeaderComponent} from '@header/header.component';
-import {MatDialog} from '@angular/material/dialog';
-import {ActivatedRoute} from '@angular/router';
-import {LoginDialogComponent} from '@shared-components/login/login.component';
-import {KeyValuePipe, NgForOf, NgIf} from '@angular/common';
-import {FormType} from './form_type';
-import {MatButton} from '@angular/material/button';
-import {AuthService} from '@services/auth.service';
+import {RouterLink} from '@angular/router';
 
 @Component({
   selector: 'app-forms',
   imports: [
     HeaderComponent,
-    NgIf,
-    NgForOf,
-    MatButton,
-    KeyValuePipe
+    RouterLink
   ],
   templateUrl: './forms.component.html',
   styleUrl: './forms.component.scss'
 })
-export class FormsComponent implements OnInit {
+export class FormsComponent {
   @Input() formTitle: string = 'Form';
   @Input() currentPage: string = 'forms';
-
-  public type: FormType | undefined;
-
-  constructor(private authService: AuthService,
-              private dialog: MatDialog,
-              private route: ActivatedRoute,
-  ) {
-    this.route.paramMap.subscribe(async params => {
-      const code = params.get('code');
-
-      if (code) {
-        this.authService.login(code).subscribe();
-      } else if (!this.authService.checkAuthStatus()) {
-        const dialogRef = this.dialog.open(LoginDialogComponent, {
-          width: '400px',
-          disableClose: true
-        });
-
-        dialogRef.afterClosed().subscribe();
-      }
-    });
-  }
-
-  ngOnInit() {
-    this.route.paramMap.subscribe(params => {
-      switch (params.get('form')) {
-        case FormType.APPEAL:
-          this.type = FormType.APPEAL;
-          this.currentPage = 'appeal';
-          break;
-        default:
-          throw new Error("Invalid type");
-      }
-    });
-  }
-
-  protected readonly FormType = FormType;
-  protected readonly Object = Object;
-
-  public setFormType(formType: FormType) {
-    this.type = formType;
-  }
 }

frontend/src/app/pages/forms/sent/sent.component.html

@@ -0,0 +1,13 @@
+<div>
+  <app-header [current_page]="'appeal'" height="200px" background_image="/public/img/backgrounds/staff.png"
+              [overlay_gradient]="0.5">
+    <div class="title" header-content>
+      <h1>Form completed</h1>
+    </div>
+  </app-header>
+  <main>
+    <section class="darkmodeSection">
+      <p>{{ message }}</p>
+    </section>
+  </main>
+</div>

frontend/src/app/pages/forms/sent/sent.component.spec.ts

@@ -0,0 +1,23 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { SentComponent } from './sent.component';
+
+describe('SentComponent', () => {
+  let component: SentComponent;
+  let fixture: ComponentFixture<SentComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [SentComponent]
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(SentComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

frontend/src/app/pages/forms/sent/sent.component.ts

@@ -0,0 +1,26 @@
+import {Component, inject, OnInit} from '@angular/core';
+import {Router} from '@angular/router';
+import {HeaderComponent} from '@header/header.component';
+
+@Component({
+  selector: 'app-sent',
+  imports: [
+    HeaderComponent
+  ],
+  templateUrl: './sent.component.html',
+  styleUrl: './sent.component.scss',
+  standalone: true
+})
+export class SentComponent implements OnInit {
+  protected message: string = "The form is completed and has been sent";
+  private router: Router = inject(Router)
+
+  ngOnInit() {
+    const state = this.router.getCurrentNavigation()?.extras.state || history.state;
+
+    if (state && 'message' in state) {
+      this.message = state.message as string;
+    }
+  }
+
+}

frontend/src/app/pages/forms/staff-application/staff-application.component.html

@@ -0,0 +1,334 @@
+<div>
+  <app-header [current_page]="'staff-application'" height="200px" background_image="/public/img/backgrounds/staff.png"
+              [overlay_gradient]="0.5">
+    <div class="title" header-content>
+      <h1>Staff Application</h1>
+    </div>
+  </app-header>
+  <main>
+    @if (staffApplicationsIsOpen()) {
+      <section class="darkmodeSection staff-application-container">
+        <div class="form-container">
+          <div class="pages">
+            <!-- Welcome Page -->
+            @if (currentPageIndex === 0) {
+              <section class="formPage">
+                <img ngSrc="/public/img/logos/logo.png" alt="Logo" height="319" width="550"/>
+                <h1>Moderator Application</h1>
+                <p>Thank you for your interest in becoming a moderator on our Minecraft server.</p>
+                <p>Please take your time to fill out this application thoroughly.</p>
+                <button mat-raised-button (click)="nextPage()">
+                  Get Started
+                </button>
+              </section>
+            }
+
+            <!-- Confirmation Page -->
+            @if (currentPageIndex === 1) {
+              <section class="formPage">
+                <div class="description">
+                  <p>You are logged in as <strong>{{ authService.username() }}</strong>. If this is the correct account
+                    please continue</p>
+                  <br>
+                  <p><strong>Notice: </strong> Submitting a staff application is <strong>not</strong> an instant
+                    process.
+                    We will review your application carefully and get back to you if we think you're a good fit.</p>
+                  <p style="font-style: italic;">Applications that seem to have been made with
+                    little to no effort will be automatically rejected.</p>
+                </div>
+                <button mat-raised-button (click)="nextPage()" [disabled]="authService.username() == null">
+                  I, {{ authService.username() }}, understand and agree
+                </button>
+              </section>
+            }
+
+            <form [formGroup]="form">
+              <!-- Basic Information Page -->
+              @if (currentPageIndex === 2) {
+                <section class="formPage">
+                  <div class="description">
+                    <h2>Basic Information</h2>
+
+                    <!-- Email -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Email</mat-label>
+                      <input matInput
+                             formControlName="email"
+                             placeholder="Email">
+                      @if (form.controls.email.invalid && form.controls.email.touched) {
+                        <mat-error>
+                          @if (form.controls.email.errors?.['required']) {
+                            Email is required
+                          } @else if (form.controls.email.errors?.['email']) {
+                            Please enter a valid email address
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+                    @if (emailIsValid()) {
+                      <div class="valid-email">
+                        <ng-container matSuffix>
+                          <mat-icon>check</mat-icon>
+                          <span>You have validated your email previously.</span>
+                        </ng-container>
+                      </div>
+                    } @else {
+                      <div class="invalid-email">
+                        <ng-container matSuffix>
+                          <mat-icon>close</mat-icon>
+                          <span>You have not used this email address before. Before going to the next page you will be asked to verify it.</span>
+                        </ng-container>
+                      </div>
+                    }
+
+                    <!-- Age -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Age</mat-label>
+                      <input matInput
+                             formControlName="age"
+                             placeholder="Age">
+                      @if (form.controls.age.invalid && form.controls.age.touched) {
+                        <mat-error>
+                          @if (form.controls.age.errors?.['required']) {
+                            Age is required
+                          } @else if (form.controls.age.errors?.['min']) {
+                            You must be at least 13 years old
+                          } @else if (form.controls.age.errors?.['pattern']) {
+                            Please enter a valid number
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Discord Username -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Discord Username</mat-label>
+                      <input matInput
+                             formControlName="discordUsername"
+                             placeholder="Discord Username">
+                      @if (form.controls.discordUsername.invalid && form.controls.discordUsername.touched) {
+                        <mat-error>
+                          Discord username is required
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- PC Requirements -->
+                    <div class="checkbox-field">
+                      <mat-checkbox formControlName="meetsRequirements">
+                        I confirm that I meet the PC requirements (able to record video at 30fps 720p or higher, and
+                        able
+                        to talk in voice chat)
+                      </mat-checkbox>
+                      @if (form.controls.meetsRequirements.invalid && form.controls.meetsRequirements.touched) {
+                        <mat-error class="checkbox-error">
+                          You must meet the PC requirements to apply
+                        </mat-error>
+                      }
+                    </div>
+
+                    <!-- Pronouns (Optional) -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Pronouns (Optional)</mat-label>
+                      <input matInput
+                             formControlName="pronouns"
+                             placeholder="Pronouns">
+                    </mat-form-field>
+                  </div>
+                  <button mat-raised-button (click)="validateMailOrNextPage()"
+                          [disabled]="form.controls.email.invalid || form.controls.age.invalid || form.controls.discordUsername.invalid || !form.controls.meetsRequirements.value">
+                    Next
+                  </button>
+                </section>
+              }
+
+              <!-- Experience Page -->
+              @if (currentPageIndex === 3) {
+                <section class="formPage">
+                  <div class="description">
+                    <h2>Experience & Availability</h2>
+
+                    <!-- Join Date -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>When did you join our server? (Estimate)</mat-label>
+                      <input matInput [matDatepicker]="picker" formControlName="joinDate">
+                      <mat-datepicker-toggle matIconSuffix [for]="picker"></mat-datepicker-toggle>
+                      <mat-datepicker #picker></mat-datepicker>
+                      @if (form.controls.joinDate.invalid && form.controls.joinDate.touched) {
+                        <mat-error>
+                          Join date is required
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Weekly Playtime -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Average expected playtime in a week (hours)</mat-label>
+                      <input matInput
+                             formControlName="weeklyPlaytime"
+                             placeholder="Hours per week">
+                      @if (form.controls.weeklyPlaytime.invalid && form.controls.weeklyPlaytime.touched) {
+                        <mat-error>
+                          @if (form.controls.weeklyPlaytime.errors?.['required']) {
+                            Weekly playtime is required
+                          } @else if (form.controls.weeklyPlaytime.errors?.['min']) {
+                            Weekly playtime must be at least 1 hour
+                          } @else if (form.controls.weeklyPlaytime.errors?.['pattern']) {
+                            Please enter a whole number of hours (e.g., 20)
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Available Days -->
+                    <div class="field-container">
+                      <label class="field-label">Available days for moderating:</label>
+                      <div class="days-container">
+                        @for (day of availableDays; track day) {
+                          <div class="day-chip" [class.selected]="form.controls.availableDays.value.includes(day)"
+                               (click)="toggleDay(day)">
+                            {{ day }}
+                          </div>
+                        }
+                      </div>
+                      @if (form.controls.availableDays.invalid && form.controls.availableDays.touched) {
+                        <mat-error>
+                          Please select at least one day
+                        </mat-error>
+                      }
+                    </div>
+
+                    <!-- Available Times -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Available times (Your timezone: {{ userTimezone }})</mat-label>
+                      <textarea matInput
+                                formControlName="availableTimes"
+                                placeholder="e.g., 6PM-10PM weekdays, 2PM-8PM weekends"
+                                rows="2"></textarea>
+                      @if (form.controls.availableTimes.invalid && form.controls.availableTimes.touched) {
+                        <mat-error>
+                          Available times are required
+                        </mat-error>
+                      }
+                    </mat-form-field>
+                  </div>
+                  <button mat-raised-button (click)="nextPage()"
+                          [disabled]="form.controls.joinDate.invalid || form.controls.weeklyPlaytime.invalid || form.controls.availableDays.invalid || form.controls.availableTimes.invalid">
+                    Next
+                  </button>
+                </section>
+              }
+
+              <!-- Qualifications Page -->
+              @if (currentPageIndex === 4) {
+                <section class="formPage">
+                  <div class="description">
+                    <h2>Qualifications & Expectations</h2>
+
+                    <!-- Previous Experience -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Previous experience (here or in other relevant places)</mat-label>
+                      <textarea matInput
+                                formControlName="previousExperience"
+                                placeholder="Describe your previous experience"
+                                rows="4"></textarea>
+                      @if (form.controls.previousExperience.invalid && form.controls.previousExperience.touched) {
+                        <mat-error>
+                          @if (form.controls.previousExperience.errors?.['required']) {
+                            Previous experience is required
+                          } @else if (form.controls.previousExperience.errors?.['minlength']) {
+                            Please provide more details (at least 10 characters)
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Plugin Experience -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Experience with plugins that players use on our server</mat-label>
+                      <textarea matInput
+                                formControlName="pluginExperience"
+                                placeholder="Describe your experience with our server plugins"
+                                rows="4"></textarea>
+                      @if (form.controls.pluginExperience.invalid && form.controls.pluginExperience.touched) {
+                        <mat-error>
+                          @if (form.controls.pluginExperience.errors?.['required']) {
+                            Plugin experience is required
+                          } @else if (form.controls.pluginExperience.errors?.['minlength']) {
+                            Please provide more details (at least 10 characters)
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Moderator Expectations -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>What do you believe the expectations of a moderator are?</mat-label>
+                      <textarea matInput
+                                formControlName="moderatorExpectations"
+                                placeholder="Describe what you think a moderator should do"
+                                rows="4"></textarea>
+                      @if (form.controls.moderatorExpectations.invalid && form.controls.moderatorExpectations.touched) {
+                        <mat-error>
+                          @if (form.controls.moderatorExpectations.errors?.['required']) {
+                            Moderator expectations are required
+                          } @else if (form.controls.moderatorExpectations.errors?.['minlength']) {
+                            Please provide more details (at least 10 characters)
+                          }
+                        </mat-error>
+                      }
+                    </mat-form-field>
+
+                    <!-- Additional Information -->
+                    <mat-form-field appearance="fill" style="width: 100%;">
+                      <mat-label>Additional Information (Optional)</mat-label>
+                      <textarea matInput
+                                formControlName="additionalInfo"
+                                placeholder="Any additional information you'd like to share"
+                                rows="4"></textarea>
+                    </mat-form-field>
+                  </div>
+                  <button mat-raised-button (click)="onSubmit()"
+                          [disabled]="isFormInvalid() || isSubmitting()">
+                    Submit Application
+                  </button>
+                </section>
+              }
+            </form>
+          </div>
+
+          <!-- Navigation dots -->
+          @if (totalPages.length > 1) {
+            <div class="form-navigation">
+              <button mat-icon-button class="nav-button" (click)="previousPage()" [disabled]="isFirstPage()">
+                <mat-icon>navigate_before</mat-icon>
+              </button>
+
+              @for (i of totalPages; track i) {
+                <div
+                  class="nav-dot"
+                  [class.active]="i === currentPageIndex"
+                  (click)="goToPage(i)">
+                </div>
+              }
+
+              <button mat-icon-button class="nav-button" (click)="nextPage()" [disabled]="isLastPage()">
+                <mat-icon>navigate_next</mat-icon>
+              </button>
+            </div>
+          }
+        </div>
+      </section>
+    } @else {
+      <section class="darkmodeSection staff-application-container">
+        <div>
+          <h1>Staff applications closed</h1>
+          <p class="center">Staff applications are closed at this time. Please keep an eye on our announcement channel
+            in Discord to
+            see
+            when it opens!</p>
+        </div>
+      </section>
+    }
+  </main>
+</div>