RegApp

https://gitlab.kit.edu/kit/reg-app/regapp/-/tree/main/documentation
Admin
RegApp is a registration application, likely for managing users, courses, or events, featuring user...
Tokens:5,342
Snippets:27
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Event API for Registration Events (Java)

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

This Java code demonstrates the usage of a new event-based API, replacing JMS. It shows how to publish a 'RegistrationComplete' event using an EventPublisher and includes an example of an event listener that processes these events. This approach decouples services and enables asynchronous communication.

```java
// Event API without JMS
import edu.kit.regapp.event.EventPublisher;
import edu.kit.regapp.event.RegistrationEvent;

EventPublisher publisher = new EventPublisher();

// Publish registration event
RegistrationEvent event = new RegistrationEvent();
event.setUserId("user123");
event.setEventType(EventType.REGISTRATION_COMPLETE);
event.setTimestamp(Instant.now());

publisher.publish(event);

// Subscribe to events
@EventListener
public class RegistrationEventListener {

    public void onRegistrationComplete(RegistrationEvent event) {
        // Process event: send welcome email, provision resources, etc.
        System.out.println("User registered: " + event.getUserId());
    }
}
```

--------------------------------

### Manage Projects via REST API (Bash)

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Provides bash commands for interacting with the RegApp project management REST API for service administrators. It includes examples for listing, retrieving, creating, updating, and deleting projects. Authentication is handled via a bearer token, and requests typically use JSON for request and response bodies.

```bash
# Project management API endpoints
# See merge request !133 for complete implementation

# List all projects (service admin)
curl -X GET https://regapp.example.edu/api/service-admin/projects \
  -H "Authorization: Bearer ${ADMIN_TOKEN}" \
  -H "Accept: application/json"

# Get project details
curl -X GET https://regapp.example.edu/api/service-admin/projects/162944 \
  -H "Authorization: Bearer ${ADMIN_TOKEN}" \
  -H "Accept: application/json"

# Create new project
curl -X POST https://regapp.example.edu/api/service-admin/projects \
  -H "Authorization: Bearer ${ADMIN_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "New Research Project",
    "description": "Research project for quantum computing",
    "ownerId": "user123",
    "status": "active"
  }'

# Update project
curl -X PUT https://regapp.example.edu/api/service-admin/projects/162944 \
  -H "Authorization: Bearer ${ADMIN_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "status": "completed",
    "endDate": "2024-12-31"
  }'

# Delete project
curl -X DELETE https://regapp.example.edu/api/service-admin/projects/162944 \
  -H "Authorization: Bearer ${ADMIN_TOKEN}"

# Response format:
# {
#   "projectId": 162944,
#   "name": "RegApp",
#   "status": "active",
#   "created": "2015-01-27T00:00:00Z",
#   "lastUpdated": "2024-08-15T10:30:00Z"
# }
```

--------------------------------

### Building RegApp Project with Maven

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Provides essential Maven commands for building, testing, and packaging the RegApp project. Includes options for custom settings, skipping tests, building specific modules, generating documentation, and managing code formatting.

```bash
# Build the entire project
mvn clean install

# Build with custom settings
mvn clean install -s maven/settings.xml

# Skip tests during build
mvn clean install -DskipTests

# Build specific module
cd regapp-webapp
mvn clean package

# Generate documentation
mvn site

# Run code formatting (Spotless)
mvn spotless:apply

# Check code formatting
mvn spotless:check
```

--------------------------------

### Exploring RegApp Project Modules with Bash

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Provides bash commands to list the contents of key directories within the RegApp project, illustrating the modular structure for entities, persistence, services, and authentication components.

```bash
# Entity and persistence modules
ls bwreg-entities/  # Business workflow entities
ls bwreg-jpa/       # JPA implementations with LAZY loading
ls regapp-jpa-api/  # JPA API definitions
ls regapp-jpa-impl/ # JPA implementations

# Service layer modules
ls regapp-ejb-service/  # EJB-based services
ls regapp-reg-api/      # Registration API
ls regapp-reg-impl/     # Registration implementation
ls bwreg-service/       # Core business services

# Authentication modules
ls regapp-idty/      # Identity management
ls regapp-saml/      # SAML authentication
ls regapp-saml-idp/  # SAML Identity Provider
ls regapp-saml-sp/   # SAML Service Provider
ls regapp-oidc/      # OpenID Connect support
ls regapp-oidc-op/   # OIDC Provider
ls regapp-oidc-rp/   # OIDC Relying Party

# Feature modules
ls regapp-twofa/     # Two-factor authentication
ls regapp-sshkey/    # SSH key management
ls regapp-project/   # Project management
ls regapp-session/   # Session management
```

--------------------------------

### Viewing GitLab CI Configuration for RegApp

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Shows how to view the Continuous Integration and Continuous Deployment (CI/CD) configuration files for the RegApp project hosted on GitLab. It also outlines the typical stages in a CI/CD pipeline.

```bash
# View GitLab CI configuration
cat .gitlab-ci.yml
cat .gitlab-ci-release.yml

# Pipeline stages typically include:
# 1. Build - Compile all modules
# 2. Test - Run unit and integration tests
# 3. Quality - Code analysis and formatting checks
# 4. Package - Create deployment artifacts
# 5. Release - Deploy to target environments

# Trigger pipeline manually via GitLab UI:
# Project → CI/CD → Pipelines → Run Pipeline
```

--------------------------------

### Build and Run Quarkus Application

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

These are command-line instructions for building and running a Quarkus application. It uses Maven for building the package and then executes the generated JAR file. Ensure the target JAR file name matches the output of the build process.

```bash
// Build Quarkus application
// mvn clean package -Pquarkus
// java -jar target/regapp-quarkus-runner.jar
```

--------------------------------

### Quarkus Application Main Entry Point

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

This Java code snippet demonstrates the main entry point for a Quarkus application. It initializes the Quarkus runtime and waits for the application to exit. Dependencies are managed by Quarkus's CDI.

```java
// Quarkus integration for modern microservices
// See feature/ISSUE-261 for implementation

import io.quarkus.runtime.Quarkus;
import io.quarkus.runtime.QuarkusApplication;
import io.quarkus.runtime.annotations.QuarkusMain;
import javax.inject.Inject;

@QuarkusMain
public class RegAppQuarkusMain implements QuarkusApplication {

    @Inject
    RegistrationService registrationService;

    @Override
    public int run(String... args) throws Exception {
        System.out.println("RegApp Quarkus starting...");
        Quarkus.waitForExit();
        return 0;
    }
}
```

--------------------------------

### Apply and Check Code Formatting with Maven

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Applies and checks code formatting using the Spotless Maven plugin. Ensure the 'eclipse-formatter.xml' is configured for IDE integration.

```bash
# Format specific module
cd regapp-event-api
mvn spotless:apply

# Check formatting without applying changes
mvn spotless:check
```

--------------------------------

### Managing RegApp Branches with Git

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Illustrates Git commands for managing branches in the RegApp project, including listing all branches, checking out specific version or feature branches, and understanding branch naming conventions.

```bash
# List all branches
git branch -a

# Protected version branches:
# - main (default protected)
# - branch-2.8 (protected)
# - branch-2.7 (protected)
# - branch-2.5 (protected)

# Switch to a specific version branch
git checkout branch-2.8

# Feature branches follow naming convention:
# feature/ISSUE-XXX_description
# Examples:
git checkout feature/ISSUE-264_update-simpleldapregisterworkflow-to-work-with-other-user-types
git checkout feature/ISSUE-261_regapp-integration-into-quarkus
git checkout feature/ISSUE-242_introduce-automated-code-formatting
```

--------------------------------

### Execute Integration Tests with Maven

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Maven commands to run integration tests, specifying database types and URLs, and generating test reports.

```bash
# Run integration tests
mvn verify -Pintegration-tests

# Test with specific database
mvn verify -Ddb.type=postgresql -Ddb.url=jdbc:postgresql://localhost:5432/regapp_test

# Generate test reports
mvn surefire-report:report

# View test results
open target/site/surefire-report.html
```

--------------------------------

### Viewing Project License

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

This bash command displays the content of the 'license.txt' file, which contains the project's license information. The license is typically an academic/institutional license for bwIdm projects.

```bash
# View project license
cat license.txt

# License type: Check license.txt for specific terms
# Typical academic/institutional license for bwIdm projects
```

--------------------------------

### Working with RegApp Release Tags in Git

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Shows how to view and checkout specific release tags for the RegApp project using Git commands. This is useful for inspecting or deploying specific versions of the software.

```bash
# List all release tags
git tag

# Recent releases (latest first):
# 2.8.5, 2.8.4, 2.8.3, 2.8.2, 2.8.1, 2.8.0
# 2.7.8, 2.7.7, 2.7.6, 2.7.5, 2.7.4, 2.7.3, 2.7.2, 2.7.1
# 2.5.14, 2.5.13, 2.5.12, 2.5.11, 2.5.10, 2.5.9

# Checkout a specific release
git checkout 2.8.5

# View commits for a release
git log 2.8.5 --oneline -10
```

--------------------------------

### Manage Project Dependencies with Maven

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Commands for checking dependency updates, applying the latest versions, scanning for vulnerabilities using OWASP Dependency-Check, and analyzing the dependency tree.

```bash
# Check for dependency updates
mvn versions:display-dependency-updates

# Update dependencies (see ISSUE-232)
mvn versions:use-latest-versions

# Check for CVE vulnerabilities
mvn org.owasp:dependency-check-maven:check

# View CVE suppression rules
cat cve-suppression.xml

# Analyze dependency tree
mvn dependency:tree > dependency-tree.txt
```

--------------------------------

### Cloning RegApp Repository with Git

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Demonstrates how to clone the RegApp project repository from GitLab using both SSH and HTTPS protocols. It also shows how to navigate into the project directory.

```bash
# Clone the repository via SSH
git clone git@gitlab.kit.edu:kit/reg-app/regapp.git

# Clone the repository via HTTPS
git clone https://gitlab.kit.edu/kit/reg-app/regapp.git

# Navigate to project root
cd regapp
```

--------------------------------

### Apply Code Formatting with Maven (Bash)

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Demonstrates how to apply code formatting using the Eclipse formatter configuration with Maven. The `mvn spotless:apply` command formats the code according to the rules defined in the `eclipse-formatter.xml` file. This ensures consistent code style across the project.

```bash
# Apply Eclipse formatter configuration
mvn spotless:apply -f pom.xml

# Configuration file
cat eclipse-formatter.xml

```

--------------------------------

### Git Branching and Contribution Workflow

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

This bash snippet outlines the Git workflow for contributing to the project. It covers forking the repository, creating a feature branch with a specific naming convention, committing changes, pushing to a fork, and creating a merge request in GitLab. It also mentions referencing issues and requesting reviews.

```bash
# Fork the repository in GitLab
# Create feature branch following naming convention
git checkout -b feature/ISSUE-XXX_description

# Make changes and commit
git add .
git commit -m "ISSUE-XXX: Description of changes"

# Push to your fork
git push origin feature/ISSUE-XXX_description

# Create merge request via GitLab UI
# - Target branch: main
# - Fill in merge request template
# - Reference issue numbers: Closes #XXX
# - Request review from maintainers

# Merge request example (see !133):
# Title: Make project api for service admins more complete rest project service admin
# Description: Closes #270 and #266
# Target: main
```

--------------------------------

### Perform Database Migrations with Liquibase

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Utilizes Liquibase via Maven to manage database schema changes. Includes generating diffs, applying updates, rolling back, and checking status.

```bash
# Generate liquibase changeset
cd regapp-jpa-impl
mvn liquibase:diff

# Apply database changes
mvn liquibase:update

# Rollback last change
mvn liquibase:rollback -Dliquibase.rollbackCount=1

# View pending changes
mvn liquibase:status
```

--------------------------------

### Link and Unlink User Accounts

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Java code demonstrating the use of AccountLinkingService to link two existing accounts with a verification token and to unlink them.

```java
// Account linking functionality
// See merge request for feature implementation

import edu.kit.regapp.account.AccountLinkingService;

AccountLinkingService linkingService = new AccountLinkingService();

// Link two accounts
AccountLinkRequest request = new AccountLinkRequest();
request.setPrimaryAccountId("user123");
request.setSecondaryAccountId("user456");
request.setLinkType(LinkType.SAML_TO_LOCAL);
request.setVerificationToken("token-from-email");

try {
    AccountLinkResult result = linkingService.linkAccounts(request);
    if (result.isSuccess()) {
        System.out.println("Accounts linked successfully");
        System.out.println("Primary ID: " + result.getPrimaryAccountId());
        System.out.println("Linked identities: " + result.getLinkedIdentities());
    }
} catch (AccountLinkingException e) {
    System.err.println("Linking failed: " + e.getMessage());
    // Handle cases: accounts already linked, verification failed, etc.
}

// Unlink accounts
linkingService.unlinkAccounts("user123", "user456");
```

--------------------------------

### Configure OIDC Service Client in Java

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Sets up a service OIDC client for service-to-service authentication. It configures the client ID, client secret, and token endpoint. The `invoke` method is used to obtain an access token, which is then printed to the console.

```java
// ServiceOIDCClient with invoke method
// See feature/ISSUE-226 for implementation

import edu.kit.regapp.oidc.ServiceOIDCClient;

ServiceOIDCClient oidcClient = new ServiceOIDCClient();
oidcClient.setClientId("service-client-001");
oidcClient.setClientSecret("secret");
oidcClient.setTokenEndpoint("https://auth.example.edu/token");

// Invoke method for service-to-service authentication
TokenResponse token = oidcClient.invoke(requestParams);
System.out.println("Access Token: " + token.getAccessToken());
```

--------------------------------

### POST /api/v2/registration/register

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Registers a new user. This endpoint is part of the Quarkus framework integration for modern microservices.

```APIDOC
## POST /api/v2/registration/register

### Description
Registers a new user by accepting user registration details and returning the registration result or an error.

### Method
POST

### Endpoint
/api/v2/registration/register

### Parameters
#### Request Body
- **dto** (UserRegistrationDTO) - Required - User registration data.

### Request Example
```json
{
  "example": "{\"username\": \"testuser\", \"email\": \"test@example.com\"}"
}
```

### Response
#### Success Response (200)
- **RegistrationResult** (RegistrationResult) - The result of the user registration.

#### Response Example
```json
{
  "example": "{\"userId\": \"user123\", \"status\": \"SUCCESS\"}"
}
```

#### Error Response (400)
- **error** (string) - A message describing the registration error.

#### Response Example
```json
{
  "example": "{\"error\": \"Invalid email format\"}"
}
```
```

--------------------------------

### Configure SAML User Entity in Java

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Configures a SAML user entity with identity provider details and name identifiers. It utilizes lazy loading for the identity provider and specifies the entity ID. The code assumes the existence of `identityProvider` variable and highlights assertion storage options in the `regapp-idty` module.

```java
// Example SAML configuration in regapp-saml module
import edu.kit.regapp.saml.SamlUserEntity;

// Configure SAML entity with lazy loading
SamlUserEntity samlUser = new SamlUserEntity();
samlUser.setIdp(identityProvider); // LAZY loading enabled
samlUser.setNameId("user@example.edu");
samlUser.setEntityId("https://idp.example.edu/saml");

// Handle SAML assertion storage (configurable)
// See regapp-idty module for assertion storage options
```

--------------------------------

### Event Publishing API

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

API for publishing and subscribing to events within the RegApp. This replaces the old JMS-based approach.

```APIDOC
## Event Publishing API

### Description
This API provides functionality to publish and subscribe to events, enabling an event-driven architecture. It is designed as a replacement for the previous JMS-based messaging system.

### Method
PUBLISH / SUBSCRIBE

### Endpoint
N/A (Programmatic Interface)

### Parameters
#### Event Publishing
- **event** (RegistrationEvent) - The event object to be published.

### Request Example (Publishing)
```java
import edu.kit.regapp.event.EventPublisher;
import edu.kit.regapp.event.RegistrationEvent;
import edu.kit.regapp.event.EventType;
import java.time.Instant;

EventPublisher publisher = new EventPublisher();

// Publish registration event
RegistrationEvent event = new RegistrationEvent();
event.setUserId("user123");
event.setEventType(EventType.REGISTRATION_COMPLETE);
event.setTimestamp(Instant.now());

publisher.publish(event);
```

### Event Subscription
- **event** (RegistrationEvent) - The event object to be processed by the listener.

### Request Example (Subscription)
```java
import edu.kit.regapp.event.EventListener;
import edu.kit.regapp.event.RegistrationEvent;

public class RegistrationEventListener implements EventListener {

    @Override
    public void onEvent(Object event) {
        if (event instanceof RegistrationEvent) {
            RegistrationEvent registrationEvent = (RegistrationEvent) event;
            // Process event: send welcome email, provision resources, etc.
            System.out.println("User registered: " + registrationEvent.getUserId());
        }
    }
}
```
```

--------------------------------

### LDAP User Registration Workflow in Java

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Implements a simple LDAP registration workflow supporting multiple user types. It sets the user type (e.g., 'student', 'staff'), configures the LDAP connection, and registers a user. The success or failure of the registration is indicated by the `RegistrationResult` object, which provides a user ID or an error message.

```java
// SimpleLdapRegisterWorkflow supports multiple user types
// See feature/ISSUE-264 for implementation details

import edu.kit.regapp.ldap.SimpleLdapRegisterWorkflow;

SimpleLdapRegisterWorkflow workflow = new SimpleLdapRegisterWorkflow();
workflow.setUserType("student"); // or "staff", "external", etc.
workflow.setLdapConnection(ldapConnection);

// Register user with LDAP backend
RegistrationResult result = workflow.registerUser(userDetails);
if (result.isSuccess()) {
    System.out.println("User registered: " + result.getUserId());
} else {
    System.err.println("Registration failed: " + result.getErrorMessage());
}
```

--------------------------------

### Unit Tests for Registration and Email Validation

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Java JUnit 5 tests for the registration service and email validator. Includes assertions for successful registration and valid/invalid email formats.

```java
// Example test for registration service
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class RegistrationServiceTest {

    @Test
    public void testUserRegistration() {
        RegistrationService service = new RegistrationService();
        UserDetails user = new UserDetails();
        user.setUsername("testuser");
        user.setEmail("test@example.edu");
        user.setPassword("SecurePassword123!");

        RegistrationResult result = service.registerUser(user);

        assertTrue(result.isSuccess());
        assertNotNull(result.getUserId());
        assertEquals("testuser", result.getUsername());
    }

    @Test
    public void testEmailValidation() {
        EmailValidator validator = new EmailValidator();

        assertTrue(validator.isValid("user@example.edu"));
        assertFalse(validator.isValid("invalid-email"));
        assertFalse(validator.isValid("@example.edu"));
        assertFalse(validator.isValid("user@"));
    }
}
```

--------------------------------

### Service Admin Index Bean in Java

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

A JSF managed bean for the service admin index page. It injects a `ProjectService` to fetch all projects and provides a method to approve projects, adding a message to the JSF context upon successful approval. This is part of the UI layer for service administration.

```java
// Fix for service_admin_index.xhtml
// See feature/ISSUE-173 for implementation

// Access service admin dashboard
// URL: https://regapp.example.edu/service-admin/index.xhtml

// JSF managed bean for service admin
@Named
@ViewScoped
public class ServiceAdminIndexBean implements Serializable {

    @Inject
    private ProjectService projectService;

    public List<Project> getAllProjects() {
        return projectService.findAllProjects();
    }

    public void approveProject(Long projectId) {
        projectService.approveProject(projectId);
        FacesContext.getCurrentInstance()
            .addMessage(null, new FacesMessage("Project approved"));
    }
}
```

--------------------------------

### Quarkus REST Endpoint for Registration

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

This Java code defines a RESTful endpoint using Quarkus to handle user registration. It exposes a POST endpoint at '/api/v2/registration/register' which accepts UserRegistrationDTO and returns RegistrationResult or an error response. It relies on a RegistrationService for the core registration logic.

```java
// REST endpoint with Quarkus
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

@Path("/api/v2/registration")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class RegistrationResource {

    @Inject
    RegistrationService service;

    @POST
    @Path("/register")
    public Response register(UserRegistrationDTO dto) {
        try {
            RegistrationResult result = service.registerUser(dto);
            return Response.ok(result).build();
        } catch (RegistrationException e) {
            return Response.status(400)
                .entity(Map.of("error", e.getMessage()))
                .build();
        }
    }
}
```

--------------------------------

### Validate and Normalize Email Addresses in Java

Source: https://context7.com/context7/gitlab_kit_edu_kit_reg-app_regapp_tree_main/llms.txt

Handles validation and normalization of email addresses, addressing corner cases like plus addressing, consecutive dots, subdomains, and IPv6 literals. It uses `EmailValidator` and `EmailNormalizer` classes to ensure emails conform to expected formats and are standardized.

```java
// Corner case handling for email addresses
// See commit b69be0ae for implementation

import edu.kit.regapp.mail.EmailValidator;
import edu.kit.regapp.mail.EmailNormalizer;

// Handle various email formats
EmailValidator validator = new EmailValidator();
EmailNormalizer normalizer = new EmailNormalizer();

String[] testEmails = {
    "user@example.com",
    "user+tag@example.com",      // Plus addressing
    "user..name@example.com",     // Consecutive dots
    "user@subdomain.example.com", // Subdomain
    "user@[IPv6:2001:db8::1]"     // IPv6 literal
};

for (String email : testEmails) {
    if (validator.isValid(email)) {
        String normalized = normalizer.normalize(email);
        System.out.println("Original: " + email);
        System.out.println("Normalized: " + normalized);
    } else {
        System.err.println("Invalid email: " + email);
    }
}
```
Tokens:
Raw