Initial structure

Installation-and-set-up/0-installation-basic-first-steps.md

+# Step-by-Step Installation and Set up Guide
+
+### Prerequisite: Access to Repos and Documentation
+Ensure you have read access to the following repositories:
+
+- **CoTA Frontend**: [Frontend GitLab Repo](https://transfer.hft-stuttgart.de/gitlab/cota/moodle-assignsubmission_dta)
+- **CoTA Backend**: [Backend GitLab Repo](https://transfer.hft-stuttgart.de/gitlab/cota/cota-backend)
+- **CoTA Test Runner JDK17**: [Test Runner GitLab Repo (JDK17)](https://transfer.hft-stuttgart.de/gitlab/cota/examples/cota-runner-jdk17-junit5)
+- **CoTA Test Runner JDK21**:  [Test Runner GitLab Repo (JDK21)](https://transfer.hft-stuttgart.de/gitlab/cota/examples/cota-runner-jdk17-junit5)
+
+### Prerequisite: Infrastucture Downloads (VirtualBox & Ubuntu 22.04 LTS Desktop)
+Download and install the following:
+
+- [VirtualBox 7.0.14](https://download.virtualbox.org/virtualbox/7.0.14/VirtualBox-7.0.14-161095-Win.exe)
+- [Ubuntu 22.04 LTS Desktop ISO](https://ubuntu.com/download/desktop/thank-you?version=22.04.3&architecture=amd64)
+
+---
+
+## Host Installation
+
+1. Install **VirtualBox**.
+2. [Optional] Install VirtualBox Guest Additions for better integration.
+
+---
+
+## Virtual Machine (VM) Installation
+
+1. **Create a new VM** in VirtualBox with the following settings:
+   - **CPU**: 2 CPUs x 1 Core
+   - **RAM**: 4 GB
+   - **HDD**: 40 GB
+   - **Network**: Default settings
+   - **ISO Image**: Use the downloaded Ubuntu 22.04 LTS Desktop ISO
+
+2. **Start the VM** and proceed with the installation:
+   - Choose `Install Ubuntu`.
+   - Select `Minimal Installation`.
+   - Accept default settings.
+   - Create a user (use your initials or a username of choice).
+
+---
+
+## Inside Ubuntu 22.04 LTS Desktop (Minimal Installation Setup)
+
+1. Update the package list:
+   ```bash
+   sudo apt update
+   ```
+
+2. Install required packages (jdk17 or 21):
+   ```bash
+   sudo apt install git openjdk-17-jdk maven docker.io docker-compose
+   ```
+   or:
+   ```bash
+   sudo apt install git openjdk-21-jdk maven docker.io docker-compose
+   ```
+
+3. Download and install **Eclipse IDE**:
+   - Download: [Eclipse IDE for Java EE Developers](https://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/2023-12/R/eclipse-jee-2023-12-R-linux-gtk-x86_64.tar.gz)
+   - Create an Eclipse directory:
+     ```bash
+     sudo mkdir /opt/eclipse
+     sudo chown root:docker /opt/eclipse
+     ```
+   - Unpack the downloaded file:
+     ```bash
+     sudo tar xvzf ~/Downloads/eclipse-jee-2023-12-R-linux-gtk-x86_64.tar.gz -C /opt/eclipse
+     ```
+   - Create a symbolic link for Eclipse:
+     ```bash
+     sudo ln -s /opt/eclipse/eclipse /usr/local/bin/eclipse
+     ```
+
+---
\ No newline at end of file

Installation-and-set-up/application-run.md

+## Running the Application
+
+1. Create a directory for the **cota** (Note: you can also use your test-runner directory): 
+   ```bash
+   mkdir ~/cota
+   cp -R ~/dev/dtabackend/ifc/generic-proxy/ ~/cota
+   ```
+
+2. Set up the environment:
+   ```bash
+   sudo mkdir /tmp/dta-tests
+   sudo chown root:docker /tmp/dta-tests
+   export EGID=$(getent group docker | cut -d: -f3)
+   cd ~/cota
+   docker-compose up -d
+   ```
+
+3. Check if the containers are running successfully:
+   ```bash
+   docker container ls
+   ```
+
+---
+
+## Application Setup
+
+1. **Moodle Installation**:
+   - Follow the Moodle documentation in the frontend repository: [Moodle DTA Docs](https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/moodledta).
+
+2. **Testing**:
+   - See the testing documentation in the backend repository: [Backend Test Docs](https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/dtabackend).
+
+3. **View Logs**:
+   ```bash
+   docker logs -f <container_name>
+   ```
+
+4. **Stop Services**:
+   ```bash
+   docker-compose down
+   ```
+
+--- 
\ No newline at end of file

Installation-and-set-up/git-set-up.md

+## Pushing Results
+
+1. Create accounts:
+   - [GitLab Account](https://transfer.hft-stuttgart.de/gitlab) (HFT Transfer)
+   - [DockerHub Account](https://hub.docker.com/)
+
+2. Add your accounts to the necessary groups in GitLab.
+
+3. Create a Gitlab Access Token
+   To authenticate with GitLab, you will need to create a **Personal Access Token**. Follow these steps:
+
+   1. Log in to your GitLab account.
+   2. Navigate to the **User Settings** by clicking on your profile icon in the top-right corner.
+   3. Under **Access Tokens**, create a new token:
+      - **Name**: Choose a descriptive name (e.g., `GitLab Access Token`).
+      - **Scopes**: Select the appropriate scopes. For typical git operations, you will need:
+        - `api`
+        - `read_repository`
+        - `write_repository`
+      - **Expiration Date**: Set an expiration date (optional but recommended).
+   4. Click **Create Access Token** and save it securely. **This is the only time the token will be shown**.
+
+4. Configure Git to Use the Access Token
+Now that you have the access token, configure git to use it for authentication. Open a terminal and follow these steps:
+
+   1. **Cache Git Credentials** (to avoid entering the token multiple times):
+      ```bash
+      git config --global credential.helper cache
+      ```
+      This will cache your credentials for a short period of time.
+
+   2. **Set your Git Username**:
+   ```bash
+   git config --global user.name "<your_name>"
+   ```
+   Replace `<your_name>` with your GitLab username.
+
+   3. **Set your Git Email**:
+   ```bash
+   git config --global user.email "<your_email>"
+   ```
+   Replace `<your_email>` with the email associated with your GitLab account.
+
+   4. **Verify the Git Configuration**:
+   To check the configuration settings you just applied, use:
+   ```bash
+   git config -l
+   ```
+   This command will list all the global configurations for git.
+
+5. **Use the Access Token** for Git Operations:
+   When you perform a git operation (such as `git clone`, `git pull`, or `git push`) that requires authentication, Git will prompt you for a username and password. Use the following:
+   - **Username**: Your GitLab username or email.
+   - **Password**: Paste the Personal Access Token you created earlier.
+
+   Git will then authenticate using the access token.
+
+
+3. Push your results:
+   - Always pull before pushing:
+     ```bash
+     git pull
+     ```
+   - In case of conflicts:
+     ```bash
+     git merge
+     ```
+   - Push your changes:
+     ```bash
+     git push
+     ```
+   - Push the Docker image:
+     ```bash
+     docker push <image>
+     ```

Installation-and-set-up/workspace-set-up.md

+## Workspace and Loading Assets
+---
+
+1. Create a development directory and clone the repositories:
+   ```bash
+   mkdir ~/dev
+   cd ~/dev
+   git clone <repository_url>
+   ```
+
+2. Start Eclipse:
+   - Create a new workspace under `~/dev`.
+   - Ensure `.gitignore` includes Eclipse project files.
+
+3. Import the Maven projects from the file system into Eclipse.
+
+4. If necessary, create a local Maven repository by following the documentation in the backend repository.
+
+5. Add a dependency for `unifiedticketing`:
+   ```bash
+   mvn deploy:deploy-file -DgroupId=de.hftstuttgart -DartifactId=unified-ticketing -Dversion=0.2.2 -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=./local-maven-repo/unified-ticketing-0.2.2.jar
+   ```

README.md

-# cota-doc
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
+# COTA Documentation Repository
+
+This repository contains the complete codebase and documentation for the **COTA Application**, an integrated platform for [specific application purpose—add details]. It is structured into backend, frontend, infrastructure, and examples components. Below, you’ll find detailed instructions on how to set up, run, and use the application.
+
+## Table of Contents
+
+- [COTA Documentation Repository](#cota-documentation-repository)
+  - [Table of Contents](#table-of-contents)
+  - [Project Structure](#project-structure)
+  - [Running the Application](#running-the-application)
+  - [Application Components](#application-components)
+    - [1. Backend (`cota-backend`)](#1-backend-cota-backend)
+    - [2. Frontend (`cota-frontend`)](#2-frontend-cota-frontend)
+    - [3. Infrastructure (`cota-infra`)](#3-infrastructure-cota-infra)
+    - [4. Examples (`cota-examples`)](#4-examples-cota-examples)
+
+---
+
+## Project Structure
+
+```plaintext
+cota-doc/
+├── cota-backend/       # Backend service documentation
+├── cota-frontend/      # Frontend application documentation
+├── cota-infra/         # Infrastructure and deployment configuration
+├── cota-examples/      # Example implementations and usage guides
+├── img/                # Images and assets for documentation
+├── Installation-and-set-up/ # Guides for installation and setup
+├── step_by_step_installation_guide.md # Detailed installation steps
+└── README.md           # This file
 ```
-cd existing_repo
-git remote add origin https://transfer.hft-stuttgart.de/gitlab/cota/cota-doc.git
-git branch -M master
-git push -uf origin master
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://transfer.hft-stuttgart.de/gitlab/cota/cota-doc/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
 
-## Name
-Choose a self-explaining name for your project.
+---
 
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+## Running the Application
 
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
+To start the application:
 
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
+1. **Prepare the Environment**:
+   ```bash
+   mkdir ~/cota
+   cp -R ~/dev/dtabackend/ifc/generic-proxy/ ~/cota
+   sudo mkdir /tmp/dta-tests
+   sudo chown root:docker /tmp/dta-tests
+   export EGID=$(getent group docker | cut -d: -f3)
+   ```
 
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+2. **Start the Services**:
+   Navigate to the root directory and run:
+   ```bash
+   cd ~/cota
+   docker-compose up -d
+   ```
 
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
+3. **Verify Running Containers**:
+   Confirm all services are running:
+   ```bash
+   docker container ls
+   ```
 
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
+For more information, see [Installation and Set Up](Installation-and-set-up/).
 
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
+---
 
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
+## Application Components
 
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+### 1. Backend (`cota-backend`)
+- Implements APIs and core logic.
+- Technologies: [Java]
 
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+### 2. Frontend (`cota-frontend`)
+- User interface for interacting with the application.
+- Technologies: [PHP]
 
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
+### 3. Infrastructure (`cota-infra`)
+- Deployment and infrastructure configuration.
+- Technologies: [Docker]
 
-## License
-For open source projects, say how it is licensed.
+### 4. Examples (`cota-examples`)
+- Sample implementations and usage scenarios.
 
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+---

cota-backend/doc.md

+DTABackend
+Backend Rest Web Service for the Moodle Dockerized Test Agent (DTA) plugin
+
+Name
+Moodle Dockerized Test Agent (MoDTA) backend.
+
+Visuals
+See plugin docs at the Moodle HQ or the readme at https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/moodledta.
+
+Installation
+Assumption for usage: git, Java JDK 17, maven and docker installed, docker running.
+Assumption for development: Typically, a Java IDE like Eclipse JEE running. curl or an API test tool for testing.
+Only before the first build, add the dependency to unifiedticketing to your local maven repo using the command in
+deployunifiedticketingdeptolocalrepo.txt
+Build the jar using
+
+export BUILD_NUMBER=<YOUR_BUILD_NUMBER>; mvn clean install
+Assumption: members of a system group named 'docker' have access rights to the docker socket and daemon.
+Then build the docker image using (Hint: There are backticks in front of 'getent' and after 'f3')
+
+docker build --build-arg AGID=`getent group docker | cut -d: -f3` --build-arg BUILD_NUMBER=$BUILD_NUMBER -t <YOUR_DOCKERHUB_ORGANISATION>/dta-backend:latest .
+The default image is provided with the organisation hftstuttgart.
+Assumption for integration: docker-compose or a new docker version with integrated docker compose running.
+Test it without building anything e.g. with Moodle 4.3 using the provided docker-compose.yaml.
+With this compose file, after Moodle spinup
+
+install the dta plugin
+configure Moodle to open the necessary ports and hosts under Site Administration/Security/HTTP Security
+configure moodle dta plugin backend url to e.g. backendcomposedtt:8080 when using the example dockerfile
+ensure read/write access to the host temp dir for the dta plugin, e.g. with the example dockerfile for the group 'docker' to /tmp/dta-tests
+create a new course
+create a new assignment
+
+configure the assignment as Dockerized Test Agent
+provide the example repo in the teacher-dta-dir.txt example file
+
+
+add a submission to the new assignment
+
+provide the example repo in the student-dir.txt example file
+
+
+see the result!
+
+
+Usage
+See plugin docs at the Moodle HQ or the readme at https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/moodledta.
+
+Support
+Issue tracker in this Portal.
+
+Roadmap
+See issues:
+HIGH: Include agent recommendation functionality, support for Subversion version control system and kubernetes infrastructure alternatively to docker(-compose).
+MEDIUM: Enhance security by building all images to run as non-root.
+LOW: Potentially offer demo runners for further programming languages or newer Java LTS versions when available.
+
+Contributing
+You are ready to go after clone and installation, see above. Contributions welcome!
+
+Authors and acknowledgment
+Lineage:
+
+Master student project Moodle JUnit Exercise Corrector (MoJEC, 2017),
+Bachelor student project Moodle Dockerized Code Testing (MoDoCoT, 2020),
+Master thesis project Moodle Dockerized Test Tool (Moodle DTT, 2021).
+
+
+License
+See LICENSE in the root directory.
+
+Project status
+Currently under intensive development via research project AVILAB2 (see HFT research projects page).
\ No newline at end of file

step_by_step_installation_guide.md

+# Step-by-Step Installation Guide
+
+### Prerequisite: Access to Repos and Documentation
+Ensure you have read access to the following repositories:
+
+- **CoTA Frontend**: [Frontend GitLab Repo](https://transfer.hft-stuttgart.de/gitlab/cota/moodle-assignsubmission_dta)
+- **CoTA Backend**: [Backend GitLab Repo](https://transfer.hft-stuttgart.de/gitlab/cota/cota-backend)
+- **CoTA Test Runner JDK17**: [Test Runner GitLab Repo (JDK17)](https://transfer.hft-stuttgart.de/gitlab/cota/examples/cota-runner-jdk17-junit5)
+- **CoTA Test Runner JDK21**:  [Test Runner GitLab Repo (JDK21)](https://transfer.hft-stuttgart.de/gitlab/cota/examples/cota-runner-jdk17-junit5)
+
+### Prerequisite: Infra Downloads (VirtualBox & Ubuntu 22.04 LTS Desktop)
+Download and install the following:
+
+- [VirtualBox 7.0.14](https://download.virtualbox.org/virtualbox/7.0.14/VirtualBox-7.0.14-161095-Win.exe)
+- [Ubuntu 22.04 LTS Desktop ISO](https://ubuntu.com/download/desktop/thank-you?version=22.04.3&architecture=amd64)
+
+---
+
+## Host Installation
+
+1. Install **VirtualBox**.
+2. [Optional] Install VirtualBox Guest Additions for better integration.
+
+---
+
+## Virtual Machine (VM) Installation
+
+1. **Create a new VM** in VirtualBox with the following settings:
+   - **CPU**: 2 CPUs x 1 Core
+   - **RAM**: 4 GB
+   - **HDD**: 40 GB
+   - **Network**: Default settings
+   - **ISO Image**: Use the downloaded Ubuntu 22.04 LTS Desktop ISO
+
+2. **Start the VM** and proceed with the installation:
+   - Choose `Install Ubuntu`.
+   - Select `Minimal Installation`.
+   - Accept default settings.
+   - Create a user (use your initials or a username of choice).
+
+---
+
+## Inside Ubuntu 22.04 LTS Desktop (Minimal Installation Setup)
+
+1. Update the package list:
+   ```bash
+   sudo apt update
+   ```
+
+2. Install required packages:
+   ```bash
+   sudo apt install git openjdk-17-jdk maven docker.io docker-compose
+   ```
+
+3. Download and install **Eclipse IDE**:
+   - Download: [Eclipse IDE for Java EE Developers](https://www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/2023-12/R/eclipse-jee-2023-12-R-linux-gtk-x86_64.tar.gz)
+   - Create an Eclipse directory:
+     ```bash
+     sudo mkdir /opt/eclipse
+     sudo chown root:docker /opt/eclipse
+     ```
+   - Unpack the downloaded file:
+     ```bash
+     sudo tar xvzf ~/Downloads/eclipse-jee-2023-12-R-linux-gtk-x86_64.tar.gz -C /opt/eclipse
+     ```
+   - Create a symbolic link for Eclipse:
+     ```bash
+     sudo ln -s /opt/eclipse/eclipse /usr/local/bin/eclipse
+     ```
+
+---
+
+## Loading Assets
+
+1. Create a development directory and clone the repositories:
+   ```bash
+   mkdir ~/dev
+   cd ~/dev
+   git clone <repository_url>
+   ```
+
+2. Start Eclipse:
+   - Create a new workspace under `~/dev`.
+   - Ensure `.gitignore` includes Eclipse project files.
+
+3. Import the Maven projects from the file system into Eclipse.
+
+4. If necessary, create a local Maven repository by following the documentation in the backend repository.
+
+5. Add a dependency for `unifiedticketing`:
+   ```bash
+   mvn deploy:deploy-file -DgroupId=de.hftstuttgart -DartifactId=unified-ticketing -Dversion=0.2.2 -Durl=file:./local-maven-repo/ -DrepositoryId=local-maven-repo -DupdateReleaseInfo=true -Dfile=./local-maven-repo/unified-ticketing-0.2.2.jar
+   ```
+
+---
+
+## Docker Setup 
+
+1. Create and configure a Docker Compose environment:
+   - Copy the `docker-compose.yaml` file from the repository.
+   - Spin up the services using:
+     ```bash
+     docker-compose up -d
+     ```
+
+2. After starting **Moodle**:
+   - Install the DTA plugin.
+   - Configure Moodle to open the necessary ports and hosts:
+     - **Site Administration** > **Security** > **HTTP Security**.
+   - Set the DTA plugin backend URL to the Docker service name (e.g., `cahcedta:8080`).
+
+3. Ensure read/write access to the host temp directory for the DTA plugin:
+   ```bash
+   sudo chown root:docker /tmp/dta-tests
+   ```
+
+4. Configure Moodle:
+   - Create a new course.
+   - Add a new assignment.
+   - Set the assignment as **Dockerized Test Agent**.
+   - Provide the example repo in `teacher-dta-dir.txt`.
+
+5. Add a submission and provide the example repo in `student-dir.txt`.
+
+---
+
+## Pushing Results
+
+1. Create accounts:
+   - [GitLab Account](https://transfer.hft-stuttgart.de/gitlab) (HFT Transfer)
+   - [DockerHub Account](https://hub.docker.com/)
+
+2. Add your accounts to the necessary groups in GitLab.
+
+3. Create a Gitlab Access Token
+   To authenticate with GitLab, you will need to create a **Personal Access Token**. Follow these steps:
+
+   1. Log in to your GitLab account.
+   2. Navigate to the **User Settings** by clicking on your profile icon in the top-right corner.
+   3. Under **Access Tokens**, create a new token:
+      - **Name**: Choose a descriptive name (e.g., `GitLab Access Token`).
+      - **Scopes**: Select the appropriate scopes. For typical git operations, you will need:
+        - `api`
+        - `read_repository`
+        - `write_repository`
+      - **Expiration Date**: Set an expiration date (optional but recommended).
+   4. Click **Create Access Token** and save it securely. **This is the only time the token will be shown**.
+
+4. Configure Git to Use the Access Token
+Now that you have the access token, configure git to use it for authentication. Open a terminal and follow these steps:
+
+   1. **Cache Git Credentials** (to avoid entering the token multiple times):
+      ```bash
+      git config --global credential.helper cache
+      ```
+      This will cache your credentials for a short period of time.
+
+   2. **Set your Git Username**:
+   ```bash
+   git config --global user.name "<your_name>"
+   ```
+   Replace `<your_name>` with your GitLab username.
+
+   3. **Set your Git Email**:
+   ```bash
+   git config --global user.email "<your_email>"
+   ```
+   Replace `<your_email>` with the email associated with your GitLab account.
+
+   4. **Verify the Git Configuration**:
+   To check the configuration settings you just applied, use:
+   ```bash
+   git config -l
+   ```
+   This command will list all the global configurations for git.
+
+5. **Use the Access Token** for Git Operations:
+   When you perform a git operation (such as `git clone`, `git pull`, or `git push`) that requires authentication, Git will prompt you for a username and password. Use the following:
+   - **Username**: Your GitLab username or email.
+   - **Password**: Paste the Personal Access Token you created earlier.
+
+   Git will then authenticate using the access token.
+
+
+3. Push your results:
+   - Always pull before pushing:
+     ```bash
+     git pull
+     ```
+   - In case of conflicts:
+     ```bash
+     git merge
+     ```
+   - Push your changes:
+     ```bash
+     git push
+     ```
+   - Push the Docker image:
+     ```bash
+     docker push <image>
+     ```
+
+---
+
+## Running the Application
+
+1. Create a directory for the **cota**:
+   ```bash
+   mkdir ~/cota
+   cp -R ~/dev/dtabackend/ifc/generic-proxy/ ~/cota
+   ```
+
+2. Set up the environment:
+   ```bash
+   sudo mkdir /tmp/dta-tests
+   sudo chown root:docker /tmp/dta-tests
+   export EGID=$(getent group docker | cut -d: -f3)
+   cd ~/cota
+   docker-compose up -d
+   ```
+
+3. Check if the containers are running successfully:
+   ```bash
+   docker container ls
+   ```
+
+---
+
+## Application Setup
+
+1. **Moodle Installation**:
+   - Follow the Moodle documentation in the frontend repository: [Moodle DTA Docs](https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/moodledta).
+
+2. **Testing**:
+   - See the testing documentation in the backend repository: [Backend Test Docs](https://transfer.hft-stuttgart.de/gitlab/HFTSoftwareProject/dtabackend).
+
+3. **View Logs**:
+   ```bash
+   docker logs -f <container_name>
+   ```
+
+4. **Stop Services**:
+   ```bash
+   docker-compose down
+   ```
+
+---