DECATHLON_SUPPORT_SYSTEM

Decathlon Support System - Where Every Athlete Thrives! 🏆

Table of Contents

• Overview
• Features
• Repository Structure
• Modules
• Getting Started
  • Installation
  • Usage
  • Tests
• Project Roadmap
• Contributing
• License
• Acknowledgments

---

Overview

The Decathlon Support System is a comprehensive software project designed to streamline and enhance the data recording processes during a decathlon event. The core functionalities of the project are facilitated through a Next.js frontend, a Rust backend, and a reverse proxy orchestrated using Docker Compose. The backend offers features such as logging, web server capabilities, serialization, PDF generation, and AWS service interaction. Through components like certificate_generation.rs, the system manages athlete achievements, facilitates CRUD operations for athletes, groups, and achievements, thereby significantly enhancing operational efficiency within the Decathlon Support System architecture.

---

Features

	Feature	Description
⚙️	Architecture	The project follows a microservices architecture. It uses Next.js for the frontend, Rust for the backend, and a reverse proxy. Services are orchestrated in a compose.yaml file for seamless inter-service communication.
🔩	Code Quality	The codebase exhibits good code quality with adherence to best practices. It maintains consistent code style and follows standards.
📄	Documentation	The project provides detailed documentation for setting up and running the system. It includes explanations for backend Rust code, npm scripts, and containerization. The documentation supports developers in understanding and contributing to the project effectively.
🧩	Modularity	The codebase demonstrates modularity with separate frontend and backend services. Components are organized and decoupled, allowing for easy maintainability and reusability.
🧪	Testing	Testing frameworks such as Jest and React Testing Library are used for frontend testing. Backend code is tested using Rust's built-in testing capabilities.
⚡️	Performance	The system shows good efficiency and speed. Resource usage is managed effectively through containerized deployment and optimization in the Dockerfile.
🛡️	Security	Security measures include access control mechanisms for data protection. Backend services handle authentication using Next-Auth for secure user access.
📦	Dependencies	Key dependencies include Next.js, Rust, TailwindCSS, Docker, Next-Auth, and Zod for data validation. External libraries like React and TypeScript are also used.
🚀	Scalability	The project is designed for scalability with a microservices architecture. It can handle increased traffic and load by scaling individual services independently.

---

Repository Structure

└── decathlon_support_system/
    ├── README.md
    ├── backend
    │   ├── .dockerignore
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── assets
    │   ├── backend.dockerfile
    │   ├── src
    │   └── tests
    ├── compose.yaml
    ├── deployment
    │   ├── nginx.conf
    │   └── nginx.dockerfile
    ├── frontend
    │   ├── .eslintrc.json
    │   ├── .gitignore
    │   ├── README.md
    │   ├── frontend.dockerfile
    │   ├── next.config.js
    │   ├── package-lock.json
    │   ├── package.json
    │   ├── postcss.config.js
    │   ├── public
    │   ├── src
    │   ├── tailwind.config.ts
    │   └── tsconfig.json
    └── package.json

---

Modules

.

File	Summary
compose.yaml	Defines services for Next.js frontend, Rust backend, and a reverse proxy. Orchestrates container builds, defines environment variables, sets ports, and establishes dependencies for seamless inter-service communication within the Decathlon Support System architecture.
package.json	Coordinates frontend and backend development tasks with npm scripts. Manages seamless running and building of the Decathlon Support System components.

backend

File	Summary
Cargo.toml	Defines essential dependencies for Rust backend services in the parent repository, enabling features like logging, web server, serialization, date-time handling, PDF generation, and interacting with AWS services. Influences the operational behavior and capabilities of the backend support system.
backend.dockerfile	Builds a Rust application for Decathlon Support System backend. It compiles the source code and packages it with assets for deployment. The Dockerfile sets up the build and production stages to optimize the applications containerization.

backend.src

File	Summary
main.rs	Initiates the system by running the main function from the Decathlon Support System, handling errors through the Result type.
certificate_generation.rs	Defines traits and structs for managing athlete achievements, supporting CRUD operations for athletes, groups, and achievements. Implements parsing and comparison for floating-point numbers. Includes functions for organizing competition events based on type.
database.rs	Exports a specific database implementation for the backend, facilitating storage operations within the Decathlon Support System. Consists of modules for error handling, in-memory, and DynamoDB storage.
api_server.rs	Defines routes and handlers to start an Actix Web server, providing athlete, group, achievement, certificate, and time planner endpoints. Includes functions to check status, save/load data, and parse JSON bodies.
lib.rs	Initiates Actix Web server, connects to a database, and runs Rust API server. Implements storage traits for achievements and time planning, ensuring data serialization. Facilitates database connectivity and server shutdown within the Decathlon support system architecture.
time_planner.rs	Implements time planning and storage functionality. Defines athlete, discipline, and time group structs with relevant methods. Manages discipline states, starting orders, and updates. Handles creating default athlete and run orders.

backend.src.api_server

File	Summary
time_planner_routes.rs	Defines routes for obtaining, updating, and managing disciplines, starting orders, and time tables within the Decathlon Support System. Handles interactions with data storage and serializes responses for seamless backend functionality.
certificate_routes.rs	Enables serving PDF certificates, group, and age group results. Handles requests for specific athlete, group, or age group, generating and returning PDF responses accordingly. Closely integrated with the backends storage system for data retrieval.
athlete_routes.rs	Defines REST endpoints for managing athletes and groups in the backend server. Handles athlete creation, retrieval, updates, and group assignments. Involves serializing data and interacting with the storage layer.
group_routes.rs	Exposes routes for fetching, creating, and updating athlete groups and age groups in the backend. Handles parsing JSON data and interacting with storage. Enables seamless retrieval and management of group information.
achievement_routes.rs	Defines routes for handling achievement data in the backend API. Includes functions for fetching, creating, updating, and deleting achievements. Utilizes Actix Web for routing and storage interactions.

backend.src.database

File	Summary
dynamo_db.rs	This code file dynamo_db.rs in the backend directory of the decathlon_support_system repository provides seamless integration with DynamoDB for storing and retrieving various data related to certificates, achievements, athletes, groups, and time planning. It leverages async/await patterns and serde for JSON serialization/deserialization. By utilizing the aws_sdk_dynamodb crate, it enables efficient interaction with DynamoDB tables, facilitating robust data management for the applications core functionalities without the need for handling low-level AWS SDK operations directly.
db_errors.rs	Defines a custom error struct ItemNotFound with message and code fields. Implements traits for error handling and display. Enhances error management within the backend module to handle item-not-found scenarios effectively.
in_memory_db.rs	In_memory_db.rsinbackend/src/databaseThe in_memory_db.rsfile in thebackend/src/database` directory of the Decathlon Support System repository serves as a foundational component for managing in-memory data storage within the application. This code module facilitates the storage and retrieval of critical data entities such as achievements, athletes, and groups using a HashMap-based approach. It establishes an interface for storing and accessing data structures within a Mutex-protected environment, ensuring thread safety.By encapsulating the logic for handling data entities in-memory, this module enables efficient data management operations and seamless interaction with various components of the backend system. The file plays a pivotal role in providing a structured and accessible data layer that supports essential functionalities such as athlete and group management, thereby contributing to the overall reliability and performance of the Decathlon Support System.

backend.src.certificate_generation

File	Summary
groups.rs	Defines group structures for athletes, enabling storage, retrieval, and manipulation for competitions. Facilitates easy group creation, athlete addition, and retrieval. Supports age-based groupings for competition result generation.
age_group_utils.rs	Defines a struct and method for selecting age groups based on athlete demographics. Parses age identifiers and calculates start/end years. Ensures age group matching when comparing with athlete details.
athletes.rs	Defines athlete structure with personal details and achievements. Implements methods for data manipulation, achievement management, and ID generation. Ensures consistency and accuracy in athlete data handling within the Decathlon Support System architecture.
achievements.rs	SummaryThe achievements.rs file within the certificate_generation module in the backend section of the larger decathlon_support_system repository handles the serialization and deserialization of athlete achievements. It defines an Achievement enum with variants representing different types of achievements, utilizing serde for JSON serialization and deserialization. This code file plays a crucial role in managing and processing athlete achievement data within the system.---By focusing on defining various athlete achievements as structured data, this module contributes significantly to the functionality of the certificate generation system within the larger Decathlon Support System repository.
pdf.rs	Generates PDF certificates for athletes/groups by leveraging actix-web and printpdf libraries. Includes functions to create certificates, group results, discipline protocols, and age group-based reports. Integrated with the Decathlon Support System for seamless certificate generation and HTTP message conversion.

backend.src.certificate_generation.pdf

File	Summary
certificates.rs	The certificates.rs file in the backend directory of the Decathlon Support System repository is critical for generating PDF certificates. This functionality allows the system to dynamically create certificates for various purposes. By integrating the printpdf library and handling file operations using std::fs, this code file plays a significant role in enabling the system to produce and manage certificates seamlessly.This feature enhances the overall functionality of the Decathlon Support System by automating the certificate generation process, providing a valuable tool for users and administrators to create and distribute certificates efficiently.
pdf_generation.rs	Generates PDF documents with dynamic dimensions, adds pages, and embeds a logo. It enhances document customization while ensuring a professional appearance in the Decathlon Support System architecture.
group_results.rs	Generates PDF group results with athlete rankings, disciplines, and total points. Organizes data layout dynamically based on the number of disciplines. Handles multi-line athlete names comprehensively for clarity and readability.
discipline_protocol.rs	The discipline_protocol.rs file within the backend module of the Decathlon Support System repository facilitates the generation of discipline protocols in PDF format. By leveraging the printpdf library and core Rust functionalities, this code file defines the structure and content of discipline protocols, including text elements and formatting specifications. It integrates with the wider system architecture to enable the creation of printable, standardized documents for disciplinary purposes.This component plays a crucial role in enabling the system to produce polished and consistent discipline protocols in a portable document format, enhancing the overall efficiency and professionalism of the Decathlon Support System.

deployment

File	Summary
nginx.conf	Configures NGINX for a Decathlon support system, redirecting HTTP to HTTPS, handling SSL certificates, and proxying requests to a frontend server.
nginx.dockerfile	Exposes NGINX configuration and ports (80, 443) for the Decathlon Support System to enhance frontend and backend communication with the outside world.

frontend

File	Summary
frontend.dockerfile	Enables building and running a production-ready Next.js frontend application within Docker. Handles dependency installation, source code build, container image optimization, and runtime configuration. Supports disabling telemetry for both build and runtime environments.
tsconfig.json	Specifies TypeScript configuration for bundling the frontend module. Configures target, lib, JSX, module resolution, plugins, paths. Sets strict typing, skips lib check, enables module interop and JSON resolution. Excludes node_modules from compilation, includes TypeScript files and Next.js types.
postcss.config.js	Configures Tailwind CSS and Autoprefixer plugins for the frontend build process to enhance styling and ensure cross-browser compatibility in the Decathlon Support System repository.
tailwind.config.ts	Defines Tailwind CSS configuration for dark mode, content paths, and custom colors. The config file enhances the frontend styling by specifying color themes and content directories for Tailwind CSS to process.
package.json	Defines frontend build configurations for the Decathlon Support System. Manages development, building, linting, and starting next.js processes. Dependencies include next, next-auth, react, and others. DevDependencies encompass typescript, eslint, and tailwindcss for development workflows.
package-lock.json	The code file backend.dockerfile within the backend directory of the decathlon_support_system repository is crucial for configuring the Docker environment to deploy the backend services of the support system. This Dockerfile defines the dependencies, environment setup, and specific configurations needed to build and run the backend application within a container. It plays a key role in ensuring seamless and consistent deployment of the backend services as part of the overall support system architecture.
.eslintrc.json	Improve frontend code quality by extending core web vitals with ESLint in the Decathlon Support System repository.
next.config.js	Defines proxy rules to forward API requests to the backend server based on the environment. Configures PWA settings such as destination directory, service worker registration, and activation for the Next.js application.

frontend.src

File	Summary
middleware.ts	Implements authentication middleware utilizing NextAuth to secure routes. Config ensures specific paths bypass authentication for frontend functionality in the Decathlon Support System repository.
auth.config.ts	Defines authentication settings for different user roles in the frontend application. Handles redirection based on user roles like group, register, admin, and timing. Implements custom authentication logic.
auth.ts	Enables user authentication via server-side NextAuth implementation. Uses Credentials provider with zod for data validation. Retrieves session based on password input. Integrates with authConfig for configuration. Provides signIn and signOut functionalities within the frontend of the Decathlon Support System.

frontend.src.app

File	Summary
globals.css	Implements global styling using Tailwind CSS in the frontend section for consistent design and layout across the Decathlon Support System.
page.tsx	Implements a homepage with navigation links in frontend/src/app/page.tsx. Displays a logo and directs users to different sections of the app. Aligns with the frontend structure in the decathlon_support_system repository.
layout.tsx	Defines metadata and viewport settings for the Jedermannzehnkampf web app, ensuring proper SEO and visual configurations. Renders the root layout with language support and specialized styling.

frontend.src.app.lib

File	Summary
config.tsx	Defines default values and mappings for various athletic disciplines in the frontend, ensuring consistent data representation across decathlon, triathlon, heptathlon, and pentathlon events. Supports German states and age groups for seamless integration within the Decathlon Support System architecture.
title.tsx	Defines Title component for rendering a centered, styled heading based on the given title string within the frontend of the Decathlon Support System.
athlete_fetching.tsx	Defines athlete data structures and functions for fetching and sorting athletes based on various criteria. Contributes to the frontends capability to interact with backend APIs and display athlete information dynamically.
discipline_rules.tsx	Defines discipline rules for multiple track and field events with detailed guidelines and specifications to ensure event safety and organization. Categorizes rules by event types and includes image references for visual clarity.
sidebar.tsx	Defines a dynamic sidebar UI for navigating groups and age categories within an event registration system. Features collapsible sections, group selection functionality, and user logout option. Enhances user experience by offering intuitive navigation controls and clear categorization of event details.
parsing.tsx	Defines functions to handle number conversion and date formatting. Converts number strings to integral and fractional parts, and vice versa. Formats dates to include weekdays, hours, and minutes.
interfaces.tsx	Defines interfaces and classes for Discipline, AthleteID, AthleteTimeResult, AthleteDistanceResults, AthleteHeightResults, and AthleteHeightID in the context of the Decathlon Support System. Captures athlete and discipline data structures for event management.
user_auth.ts	Defines authentication logic using Next.js Auth. Extends User class for session handling. Implements role-based access control through backend validation. Ensures secure credential sign-ins and error handling for user authentication.
loading.tsx	Implements loading button and animation components in the frontend to enhance user experience. Handles loading state changes and click events, providing visual feedback through animated icons.

frontend.src.app.lib.achievement_edit

File	Summary
time.tsx	Enables athletes to submit time achievements with integral and fractional values. Handles form submission, updates achievement data via API calls, and displays a form for input and saving results. Achieves seamless athlete achievement tracking and storage.
api_calls.tsx	Implements functions for saving and updating athlete achievements with API calls, handling different achievement types. Handles starting order, distance, and height achievements, supporting data manipulation and network error handling.
popup.tsx	Converts achievement values to strings based on types. Render popup UI for editing achievements with dynamic content. Integrated with athlete data for seamless updates.
inline.tsx	Enables dynamic inline editing of athlete achievements, handling various types like time, distance, and height. Communicates with backend to update achievement data upon user input for seamless athlete tracking and management within the decathlon support system.
height.tsx	Manages athlete achievement editing by dynamically updating height-related data. Parses user inputs to reflect changes, allowing saving and creation of achievements._MAINTAINS athlete data integrity and facilitates achievement modification via user input.
distance.tsx	Facilitates editing distance achievements for athletes, converting and submitting data through user input. Automatically calculates final results and updates achievements via API calls, enhancing the frontend functionality of the Decathlon Support System.

frontend.src.app.timing

File	Summary
group.tsx	Generates group timing data for disciplines, displaying athlete results and allowing result editing. Fetches athlete and discipline info dynamically, providing an interactive overview for managing competition timing and achievements within the Decathlon Support System frontend architecture.
runs.tsx	Defines a component for tracking athletic event results. Displays runs, athletes details, and editable time achievements. Enhances user interaction with collapsible content and inline editing functionalities. Works alongside the backend to retrieve and update athlete data for display.
page.tsx	Implements a split-screen layout displaying admin sidebar and overview components. Supports toggling display options for different content sections. Enhances user experience and provides easy navigation within the Decathlon Support System frontend.
overview.tsx	Illustrates dynamic content rendering based on URL params for timing groups. Displays 10-event and youth discipline groups with interactive navigation. Enhances user experience through seamless group selection, routing, and information display.

frontend.src.app.admin

File	Summary
page.tsx	Illustrates Admin page layout, integrating Sidebar and Overview components. Enhances user experience with toggleable group-related features. Crucial to frontend functionality in the Decathlon Support System architecture.

frontend.src.app.admin.group_overview

File	Summary
group_overview.tsx	Generates dynamic group overviews for different categories based on URL parameters. Renders information sections for age groups, competition groups, and youth groups, allowing easy navigation and selection within the Decathlon Support System frontend.
print_utilities.tsx	Enables generating various event-related documents based on user input, such as current discipline details, protocols, group results, and certificates. Supports dynamic rendering and file downloads for efficient event management within the Decathlon Support System frontend.
achievement.tsx	Implements dynamic rendering and editing of athlete achievements in group overview UI. Displays achievement data, triggers edit pop-up, and handles editing functionality based on user interaction. Supports seamless management of athlete achievement details in the frontend application.
athltetes.tsx	Displays group athletes with achievements, sortable by columns. Dynamically fetches and updates data based on the groups age category. Enables editing of individual athlete achievements and downloading certificates. Integrates React components for interactive UI in the Decathlon Support System frontend.

frontend.src.app.admin.group_overview.disciplines

File	Summary
disciplines.tsx	Displays and manages disciplines for a specified group, fetching details via API calls. Supports editing starting orders and generating PDF protocols. Allows toggling visibility and handling PDF downloads.
discipline_edit.tsx	The discipline_edit.tsx file in the frontend directory of the decathlon_support_system repository facilitates saving starting orders within the administrative section of the system. It imports the saveStartingOrder function from the achievement_edit API calls to enable the management of starting orders for disciplines. This code enhances the functionality of the administrative interface by allowing users to modify and update starting orders efficiently.This feature contributes to the comprehensive management capabilities of the system, aligning with the overarching goal of providing robust administrative tools for effective support in organizing and overseeing athletic events.

frontend.src.app.login

File	Summary
page.tsx	Implements client authentication and password validation for the login page in the frontend app. Uses React hooks and user authentication library for form state management. Features dynamic styling based on password input.

frontend.src.app.group

File	Summary
header.tsx	Implements a dynamic header with navigation controls for user interaction. Handles logout and back-navigation based on the users history. Potential future improvement includes adding loading animations.
field.tsx	Enhances UI for group field with interactive image zoom. Utilizes a custom layout component. Supports responsive design and provides a detailed view of the field. Aligns with the frontend architecture of the Decathlon Support System repository.
title.tsx	Generates dynamic titles for UI components in the frontend using React, enhancing user experience.
page.tsx	Facilitates dynamic navigation and content display based on tabs for a web apps group page. Manages tab history, showcases various sections such as Athletes, Schedule, and Rules, adapting the view according to user interactions.
subpage_layout.tsx	Integrates layout structure for subpages in a React frontend, featuring dynamic title display and footer inclusion. Enhances user experience by maintaining consistency across pages in the Decathlon Support System repository.
navigation.tsx	Defines navigation context for frontend components with history tracking and tab navigation control using Reacts Context API. Facilitates managing navigation state and interactions within the Decathlon Support System frontend architecture.
footer.tsx	Facilitates footer navigation by utilizing context data for tab actions, enhancing user interaction in the frontend architecture of the repository.
overview.tsx	Implements dynamic tab rendering and tab change functionality for a group overview section. Displays group name and tabs list with responsive styling. Contributing to frontend user interaction in the Decathlon Support System.
timetable.tsx	Renders and manages a dynamic timetable layout for displaying disciplines per day. Fetches disciplines data, divides them by day, and allows updating starting orders. Implements interactive UI elements for viewing and editing disciplines within a group.
rules.tsx	Retrieves and displays rules for different sport disciplines, including general information. Dynamically fetches discipline data and presents it in a structured layout. Allows users to view detailed rules and information for each discipline within the group.

frontend.src.app.group.discipline

File	Summary
time_discipline.tsx	Defines and manages athlete start order for a groups discipline, supporting start, editing, and completion actions. Tracks athletes details and allows rearrangement within runs. Facilitates saving and finishing discipline processes efficiently.
discipline.tsx	Handles rendering discipline details based on type, fetching data from the API, and updating discipline state. Supports starting and finishing disciplines with corresponding API calls to facilitate seamless event management in the Decathlon Support System frontend.
distance_discipline.tsx	The distance_discipline.tsx file in the frontend/src/app/group/discipline directory facilitates managing distance discipline-related functionalities in the Decathlon Support System. It imports key interfaces like AthleteDistanceResults, AthleteID, Discipline, and StartingOrder. The code leverages Reacts context and state management for handling discipline-related operations such as starting and finishing disciplines. Additionally, it interacts with APIs for fetching group achievements, saving distance achievements, and manipulating athlete information. This file plays a crucial role in enabling smooth handling of distance discipline tasks within the larger Decathlon Support System frontend architecture.

frontend.src.app.group.discipline.height

File	Summary
height_discipline.tsx	The height_discipline.tsx file within the frontend/src/app/group/discipline/ directory of the decathlon_support_system repository facilitates the management of athlete height data and related achievements within the application. It leverages React context for state management, allowing the tracking of athlete heights and results during various disciplines. The file handles the starting and finishing of height disciplines, retrieves group achievements, and interfaces with athlete information stored in the application.
athlete_overview.tsx	Manages athlete height progress, input, and results, facilitating achievement saving and height adjustment in a competition context. Controls athlete order, tries, and completion status for effective height management and progression tracking within a competitive setting.
achievement_input.tsx	Implements athlete height input functionality based on current results and height tries.-Updates athlete results based on user interactions like updating tries, surrendering, or skipping heights.
starting_height.tsx	Enables updating and saving athlete starting heights in the discipline module. Populates height options dynamically, allows saving actions, and displays athlete details. Facilitates efficient height management within the Decathlon Support System frontend.

frontend.src.app.group.athletes

File	Summary
athletes.tsx	Facilitates displaying and updating athletes achievements in a group, integrated with search functionality. Athletes can be filtered by name or surname, revealing their achievements upon selection. Implements an athlete overview component that dynamically updates data for seamless user interaction.
achievement.tsx	Implements AchievementDisplay component for athlete achievements. Manages editing and displaying achievement values with unit conversion. Interacts with AchievementContext and trigger update functionalities.

frontend.src.app.register

File	Summary
search_table.tsx	Implements dynamic athlete table filtering and sorting with input updating. Manages athlete grouping, age calculations, and error handling. Enhances user experience within the repositorys frontend architecture.
page.tsx	Integrates Sidebar and Overview to construct an Admin view with specific toggles for showGroups, showAgeGroups, and showLateRegister within the frontend subdirectory.
group_athletes.tsx	Implements reactive athlete group management with search and add functionalities based on selected groups. Handles athlete data updates and additions, triggering API calls for backend synchronization. Integrates search input and athlete form with dynamic loading states for user interactions within the apps athlete management context.
overview.tsx	Defines overview component rendering title and group athletes based on URL parameters to display relevant content in the front end UI.

frontend.public

File	Summary
workbox-07a7b4f2.js	Decathlon_support_system/backend/src/api.rsThis code file, located within the backend/srcdirectory of thedecathlon_support_systemrepository, plays a crucial role in handling API interactions for the support system. It defines the endpoints and logic necessary for communication between the frontend and backend components. By structuring API requests and responses effectively, this file ensures seamless data exchange and facilitates the core functionality of the support system.Key Features:-Defines API endpoints for various system functionalities.-Orchestrates the processing of incoming requests and generation of appropriate responses.-Enforces consistency and reliability in data communication within the support system architecture. Overall, theapi.rs` file serves as the backbone for enabling smooth interactions between different layers of the support system, contributing significantly to its overall functionality and efficiency.
sw.js	Enables service worker registration for precaching assets and routing in the frontend to boost performance and offline capabilities, following repository architecture for Next.js app.
manifest.json	Defines manifest properties for Jedermannzehnkampf web app in frontend/public/manifest.json. Specifies app name, theme, display mode, and URL. Centralizes metadata for a standalone, portrait-oriented app experience.

---

Getting Started

System Requirements:

• NodeJS: v21.5.0

Installation

From source

1. Clone the decathlon_support_system repository:

$ git clone https://github.com/FabianTraxler/decathlon_support_system

2. Change to the project directory:

$ cd decathlon_support_system

3. Install the dependencies for both frontend and backend:

$ npm install

Usage

From source

Run decathlon_support_system in development mode using the command below:

$ npm run dev

---

Project Roadmap

• Deploy Version v1.0
• User Acceptance Test v1.0
• Use for 29. Favoritner Jedermannzehnkampf

---

License

This project is protected under the GPL-3.0 License. For more details, refer to the LICENSE file.