en	User and administrator documentation for AlekSIS, the Free School Information System

en	AlekSIS Handbook

en	# Introduction to AlekSIS

en	## Welcome

en	Welcome to AlekSIS, the Free School Information System! This handbook is a comprehensive guide on how to install, administer, and use AlekSIS and all included official apps. Its target audience are system administrators seeking to install and maintain an AlekSIS installation, people supporting the use of AlekSIS in daily processes in educational organisations, and end users who work with the software on a daily basis.

en	## On School Information Systems

en	School Information System, or for short, SIS, are software suites that help educational organisations with managing personal information about all members (e.g. students, teachers, parents and guardians) as well as organisational data like plans, pedagogic track records, and much more.

en	Generally, the goal of using School Information Systems is to help members of the school or other educational organisation to organise their work in learning and teaching, and to simplify digital processes, especially those that involve analytical evaluation, statistics, or information that is updated very frequently and should be made available to its recipients in a timely manner.

en	Ideally, School Information Systems also promote transparency between teachers and students and improve sustainability by minimising the need for paperwork.

en	## AlekSIS, the Free School Information System

en	School Information Systems have been on the rise ever since schools began digitising their management processes. Traditionally, the vendors of school management tools (like for timetabling, personal data management of teachers and students, etc.) also deliver wen applications that are tailored towards making the respective data available to those who need it.

en	As most of these solutions are proprietary products, they tend to be limited to be used together with other software of their vendors, and do not integrate nicely with other software and with processes and data sets not in the focus of the developers.

en	AlekSIS, in contrast, is a generic School Information System that aims at being universally usable for all processes and data sets in any educational organisation, and at interacting closely with other software components employed in management and lessons. You can find information on the possibilities for interacting with other software in the chapter [@sec:Integrations].

en	The development and product team has set the following goals for AlekSIS, in their dedication to support learning and teaching in the digital world:

en	Create a high-quality software product, adhering to high standards regarding data protection, data safety, security, and stability

en	Comply with as many national and regional data protection and school laws as possible (cf. [@sec:Legal])

en	Provide an extensible framework, allowing schools or their supporting IT companies to create their own apps (cf. [@sec:Development])

en	Help coding clubs and classes to understand the development as deeply as necessary to use AlekSIS for learning and creating their own apps

en	Keep AlekSIS free, open, and transparent (cf. [@sec:FOSS])

en	# The AlekSIS core

en	The AlekSIS core provides functionality and data models as a base for all apps.

en	## The concept of school terms {#sec:SchoolTerms}

en	In AlekSIS, mostly everything is based on school terms. A school term is a defined time range which can be used to link data to it. Typically, such data are learning groups, timetables or class register records. Although their name suggests it, school terms don't have to be a half or a full year. They should depend on the way how you organise data in your institution.

en	For example, if you issue reports at the end of every half year, a half year would be a good time range for your school terms because the class register statistics are evaluated for school terms.

en	Anyway, you should create a school term before you start to import or create other data entries like persons or groups.

en	### Manage school terms

en	You can manage the school terms if you login with your admin account and open the menu entry `Admin → School terms`. There you can find a list of all school terms and buttons to create, edit or delete school terms. Please be aware that there can be only one school term at time and each school term needs a unique name.

en	## The concept of persons {#sec:Persons}

en	The person model is designed to save all the data of students, teachers, guardians and any other persons of the school society. It tracks information like the following:

en	- Full name - Short name - Sex - Date of birth - Contact details (phone numbers, email) - Address details - Photo - Relation to guardians - Primary group (e. g. a class or a tutor group, cf. [@sec:Groups])

en	Except for the name, all data points are optional, so you can decide on your own (and on your local data protection laws) which data should be included in AlekSIS.

en	There are two important things you should know about persons:

en	**Persons are not automatically users:** That means that persons can be linked to an user account including things like a password and the ability to login, but they don't have to be. For example, your AlekSIS instance could save the data about parents, but you don't want them to login: In this scenario, the guardians are available as persons **without** user accounts.

en	**Persons are not linked to school terms:** As persons like students are not only at the school for one school term, persons are not linked to school terms.

en	### Manage persons

en	The main method to manage persons is the view under `People → Persons`. To add person to groups, you have to open the respective group and set the person as a member or an owner.

en	## The concept of groups {#sec:Groups}

en	The AlekSIS groups are a universal way to organise persons in collections like classes, courses, tutor groups, clubs, or any other division you could imagine. They track the following data:

en	Group name and short name

en	Owners (e. g. class or course teacher(s))

en	Members (e. g. students)

en	Parent groups (e. g. a class could be a parent group for a course)

en	Group type (e. g. class, course, club, etc.)

en	In contrast to persons, groups are supposed to be **linked to school terms** (but they don't have to be). For example, the composition of a class or a course varies from school term to school term. In order to archive historical data according to local laws, these groups have to be separeted which is solved by linking them to a school term.

en	### Manage group types You can manage your local group types by opening the menu entry `People → Group types` as an admin user.

en	### Manage groups Groups are managed on the page `People → Groups`. There you can search, view, create, change and delete groups.

en	## Import school terms, persons and groups from other data sources

en	When AlekSIS is not your single date source, all these data can be imported from other sources. You can find further information in [@sec:Integrations].

en	# Configuration and Administration {#sec:Administration}

en	## Install AlekSIS

en	### From PyPI

en	In this section we will install AlekSIS with `uWSGI` and `NGINX` on Debian bullseye.

en	#### Filesystem locations

en	AlekSIS will need and use the following paths by default:

en	`/etc/aleksis` for configuration files

en	`/var/lib/aleksis/media` for file storage (Django media)

en	`/var/backups/aleksis` for backups of database and media files

en	`/usr/local/share/aleksis/static` for static files

en	`/usr/local/share/aleksis/node_modules` for frontend dependencies

en	You can change any of the paths as you like.

en	#### Prerequisites

en	For an installation on a dedicated server, the following prerequisites are needed:

en	Debian 11

en	PostgreSQL

en	Redis

en	uWSGI

en	nginx

en	Python 3.9

en	Some system dependencies to build Python modules and manage frontend files

en	The aforementioned paths

en	#### Install system packages

en	Install some packages from the Debian package system.

en	```shell apt install uwsgi \ uwsgi-plugin-python3 \ nginx-full \ python3 \ python3-dev \ libldap2-dev \ libsasl2-dev \ yarnpkg \ python3-virtualenv \ chromium \ redis-server \ postgresql ```

en	#### Create PostgreSQL user and database

en	Generate a secure password for the database, then create the user and database.

en	```shell sudo -u postgres createuser -D -P -R -S aleksis sudo -u postgres createdb -E UTF-8 -O aleksis -T template0 -l C.UTF-8 aleksis ```

en	When asked, use the password generated above.

en	#### Create the directories for storage

en	```shell mkdir -p /etc/aleksis \ /usr/share/aleksis/{static,node_modules} \ /var/lib/aleksis/media \ /var/backups/aleksis chown -R www-data:www-data /var/lib/aleksis ```

en	#### Create AlekSIS configuration file

en	AlekSIS is configured in files in `/etc/aleksis`. Create a basic configuration file for the environment defined above by opening `/etc/aleksis/aleksis.toml` with your favourite text editor and adding the following configuration.

en	```toml static = { root = "/usr/local/share/aleksis/static", url = "/static/" } media = { root = "/var/lib/aleksis/media", url = "/media/" } node_modules = { root = "/usr/local/share/aleksis/node_modules" } secret_key = "SomeRandomValue"

en	[http] allowed_hosts = ["aleksis.example.com"]

en	[database] host = "localhost" name = "aleksis" username = "aleksis" password = "password_generated_above"

en	[backup] location = "/var/backups/aleksis"

en	[auth.superuser] username = "admin" password = "admin" email = "root@localhost" ```

en	#### Install AlekSIS itself

en	To install AlekSIS now, and run all post-install tasks, run the following commands. They will pull the AlekSIS standard distribution from `PyPI`_ and install it to the system-wide `dist-packages` of Python. Afterwards, it will download frontend dependencies from `yarnpkg`, collect static files, and migrate the database to the final schema.

en	```shell pip3 install aleksis aleksis-admin yarn install aleksis-admin collectstatic aleksis-admin migrate aleksis-admin createinitialrevisions ```

en	#### Configure uWSGI

en	uWSGI is an application server that will manage the server processes and requests. It will also run the Celery broker and scheduler for you.

en	Configure a uWSGI app by opening `/etc/uwsgi/apps-available/aleksis.ini` in an editor and inserting:

en	```shell [uwsgi] vhost = true plugins = python3 master = true enable-threads = true processes = 20 wsgi-file = /usr/local/lib/python3.9/dist-packages/aleksis/core/wsgi.py chdir = /var/lib/aleksis lazy = true lazy-apps = true attach-daemon = celery -A aleksis.core worker --concurrency=4 attach-daemon = celery -A aleksis.core beat ```

en	Afterwards, enable the app using:

en	```shell

en	ln -s /etc/uwsgi/apps-available/aleksis.ini /etc/uwsgi/apps-enabled/aleksis.ini service uwsgi restart ```

en	#### Configure the nginx webserver

en	First, you should get a TLS certificate, e.g. by using `Let's Encrypt`_.

en	Then, create a virtual host in nginx, by editing `/etc/nginx/sites-available/aleksis.example.com`.

en	```nginx upstream aleksis { server unix:///run/uwsgi/app/aleksis/socket; }

en	server { listen 80; listen [::]:80;

en	server_name aleksis.example.com;

en	return 301 https://$server_name$request_uri; }

en	server { listen 443 ssl http2; listen [::]:443 ssl http2;

en	ssl_certificate /etc/letsencrypt/certs/aleksis.example.com/fullchain.pem; ssl_certificate_key /etc/letsencrypt/certs/aleksis.example.com/privkey.pem; ssl_trusted_certificate /etc/letsencrypt/certs/aleksis.example.com/chain.pem;

en	access_log /var/log/nginx/access.log;

en	location /static { alias /usr/local/share/aleksis/static; }

en	location / { uwsgi_pass aleksis; include uwsgi_params; proxy_redirect off; proxy_pass_header Authorization; } } ```

en	Enable the virtual host:

en	ln -s /etc/nginx/sites-available/aleksis.example.com /etc/nginx/sites-enabled/aleksis.example.com service nginx restart ```

en	#### Finalisation

en	Your AlekSIS installation should now be reachable and you can login with the administration account configured above.

en	### With Docker

en	AlekSIS can also be installed using Docker, either only AlekSIS itself, or the full stack, including Redis, using docker-compose

en	#### Full stack using docker-compose

en	First, install Docker and docker-compose on your system. Also install git to get the docker-compose file and image definition.

en	apt install docker.io docker-compose git ```

en	Now, clone the distribution repository, which contains the docker-compose file.

en	git clone https://edugit.org/AlekSIS/official/AlekSIS ```

en	You should review the file `docker-compose.yaml` for any environment variables you want to change.

en	Finally, bring the stack up using:

en	```shell docker-compose up -d ```

en	AlekSIS will be reachable on port 80 if you forgot to configure the environment. You are responsible for adding a reverse proxy like nginx providing TLS, etc.

en	## Configuration files and format

en	### File locations and order

en	AlekSIS is configured through text files in the directory `/etc/aleksis/`. You can place any file types there that are supported by the `Dynaconf`_ configuration system (INI, YAML and TOML).

en	Files are evaluated in alphabetical order, with later definitions overwriting earlier ones. Normally, there will be only one configuration file, but you can make up any structure you like. If you use multiple files, it might be a good idea to number them, e.g. `00_main.toml`, `01_myschool.toml`, `99_temporary.toml`.

en	The TOML format is recommended and is the only format described in detail in AlekSIS’ documentation. For all other formats, refer to the `Dynaconf`_ documentation.

en	### Configuration file format (TOML)

en	TOML file are simple text files that define variables, much like in Python (i.e. there are scalars, lists and dictionaries). AlekSIS structures its configuration by topic.

en	A configuration file might look like this:

en	```toml secret_key = "VerySecretKeyForSessionSecurity"

en	[http] allowed_hosts = [ "aleksis.myschool.example.com", "localhost" ]

en	[database] name = "aleksis" user = "aleksis" password = "SuperSecretPassword"

en	[caching] redis = { enabled = true, address = "127.0.0.1" } ```

en	The `secret_key` setting above defines a single value. The following `http` section defines a table (cf. a dictionary) in one way, and you can see the second form of such a table in the `redis` setting (we could as well have defined another section and placed `enabled` and `address` below it as scalars).

en	This can be a bit confusing, so this documentation will explain how to configure AlekSIS on a per-feature basis.

en	## Authenticating against LDAP

en	AlekSIS can authenticate users against an LDAP directory (like OpenLDAP or Active Directory). The AlekSIS core can only authenticate and synchronise authenticated users to AlekSIS’ database. There are apps that help with tasks like mass-importing accounts and linking accounts to persons in the AlekSIS system (see below).

en	### Installing packages for LDAP support

en	Installing the necessary libraries for LDAP support unfortunately is not very straightforward under all circumstances. On Debian, install these packages:

en	```bash sudo apt install python3-ldap libldap2-dev libssl-dev libsasl2-dev python3-dev ```

en	### Configuration of LDAP support

en	Configuration is done under the ``default.ldap`` section in AlekSIS’ configuration file. For example, add something like the following to your configuration (normally in ``/etc/aleksis``; you can either append to an existing file or add a new one).

en	```toml [ldap] uri = "ldaps://ldap.myschool.edu" bind = { dn = "cn=reader,dc=myschool,dc=edu", password = "secret" }

en	[ldap.users] search = { base = "ou=people,dc=myschool,dc=edu", filter = "(uid=%(user)s)" } map = { first_name = "givenName", last_name = "sn", email = "mail" }

en	[ldap.groups] search = { base = "ou=groups,dc=myschool,dc=edu" } type = "groupOfNames" # Users in group "admins" are superusers flags = { is_superuser = "cn=admins,ou=groups,dc=myschool,dc=edu" } ```

en	## Configuration options

en	AlekSIS provides lots of options to configure your instance.

en	### Configuration file

en	All settings which are required for running an AlekSIS instance are stored in your configuration file ``/etc/aleksis/aleksis.toml``.

en	Example configuration file:

en	```toml # General config for static, media and secret key, required static = { root = "/srv/www/aleksis/data/static", url = "/static/" } media = { root = "/srv/www/aleksis/data/media", url = "/media/" } secret_key = "Xoc8eiwah3neehid2Xi3oomoh4laem"

en	# Admin contact, optional [contact] admins = [["AlekSIS - Admins", "root@example.com"]] from = 'aleksis@example.com'

en	# Allowed hosts, required [http] allowed_hosts = ["localhost"]

en	# Database for whole AlekSIS data, required [database] host = "localhost" name = "aleksis" username = "aleksis" password = "aleksis"

en	# Maintenance mode and debug, optional [maintenance] debug = true

en	# Two factor authentication with yubikey enabled, optional [2fa] enabled = true yubikey = { enabled = true }

en	# Authentication via LDAP, optional [ldap] uri = "ldaps://ldap.myschool.edu" bind = { dn = "cn=reader,dc=myschool,dc=edu", password = "secret" } map = { first_name = "givenName", last_name = "sn", email = "mail" }

en	[ldap.users] search = { base = "ou=people,dc=myschool,dc=edu", filter = "(uid=%(user)s)" }

en	[ldap.groups] search = { base = "ou=groups,dc=myschool,dc=edu" } type = "groupOfNames" # Users in group "admins" are superusers flags = { is_superuser = "cn=admins,ou=groups,dc=myschool,dc=edu" }

en	# Search index, optional [search] backend = "whoosh" index = "/srv/www/aleksis/data/whoosh_index" ```

en	### Configuration in frontend

en	Everything that must not be configured before the AlekSIS instance fully starts can be configured in frontend, such as site title and logo.

en	You can find the configuration options in your AlekSIS instance under ``Admin → Configuration``.

en	## Storage

en	### Amazon S3

en	AlekSIS allows you to configure an Amazon S3 endpoint for static and media files. This is useful e.g. for loadbalancing with multiple AlekSIS instances.

en	#### Configure an S3 endpoint

en	If you want to use an S3 endpoint to store files you have to configure the endpoint in your configuration file (`/etc/aleksis/aleksis.toml`):

en	``` # Default values [storage.s3] enabled = true endpoint_url = "https://minio.example.com" bucket_name = "aleksis-test" access_key_id = "XXXXXXXXXXXXXX" secret_key = "XXXXXXXXXXXXXXXXXXXXXX" ```

en	## OAuth2/OpenID-Connect provider

en	AlekSIS can provide OAuth2 and OpenID provider to allow other applications to authenticate users via AlekSIS.

en	### Enable provider

en	To enable the feature, you have to do the following steps

en	#### Create RSA key to validate JWT tokens

en	```shell openssl genrsa -out /etc/aleksis/oidc.pem 4096 ```

en	#### Enable feature in settings

en	Enable the feature in your local AlekSIS configuration (e.g. `/etc/aleksis/aleksis.toml`:

en	```toml [oauth2.oidc] enabled = true ```

en	#### Register OAuth2 applications in frontend

en	In the AlekSIS frontend, OAuth2 applications can be registred per User at `Account → Third-party applications`.

en	To authorize a new application, you have to click on "Login <Application Name>". Follow the instructions from your application.

en	To remove the application from your profile, use the "remove" button on the `Third-party applications` page.

en	## Backups

en	### Configuration

en	```toml # General backup configuration [backup] # GPG recipient of encrypted backups files. Public key must be in local keyring! gpg_recipient = "gpg@example.com" # Directory to store the backups location = "/var/backups/aleksis"

en	# Configuration for media backups [backup.media] # Keep 10 backups keep = 10 # Compress backups to save disk space compress = True # Encrypt Backups with GPG key configured in [backup] section encrypt = True # Clean old backups clean = True

en	# Same options for [backup.database] ```

en	### Restore

en	If you have to restore a backup, you can do this via management commands:

en	```shell # List all backups $ aleksis-admin listbackups # Restore backup (uncompressed) # Use dbrestore for db backups and mediarestore for media backups $ aleksis-admin dbrestore -i backup.psql # Restore backup (compressed) $ aleksis-admin dbrestore -z -i backup.psql.gz ```

en	### Automatic backups

en	Automatic backups are handled via celery tasks. The celery tasks can be configured via the django admin interface (Admin → Backend Admin).

en	In the admin interface, visit `PERIODIC TASKS` → `Periodic tasks` and press `Add periodic task`. In this form you can choose one of the registred tasks and configure schedules. It is also possible to configure arguments and execution options such as priorities expiration dates.

en	## Impersonation

en	Impersonation is a very useful feature to debug configuration or permission issues.

en	You are able to impersonate another AlekSIS user. To do so, visit the impersonation page (Admin → Impersonation) and choose the user you want to impersonate.

en	If you want to stop the impersonation, press Account → Stop impersonation in the navigation bar on the left.

en	## Configure Icons

en	To configure your own site logo or favicon, visit Admin → Configuration and navigate to the "Theme" section. Now you can see three file fields.

en	Logo (Banner in left navigation bar)

en	Favicon (Icon in browser tab)

en	PWA-Icon (Icon on mobile home screen)

en	## Debug tools

en	AlekSIS provides tools to debug and manipulate data. Use them only if you know what you are doing!

en	### django-extensions

en	django-extensions provides many small features to debug your AlekSIS instance from the command line. You can generate passwords and secret keys, get list of all urls, list models and signals and much more.

en	### ipython3

en	iPython3 is a powerfull python shell. You can use it to manipulate and debug the data in your AlekSIS instance. Use it with caution and be sure to have backups of your data.

en	## Preferences

en	### Site preferences

en	| Section | Purpose | |-----------------------------|-----------------------------------------------------------------------------------------------------| | General | General configuration (site title, site descirption,…) | | Theme | Theming options, e.g. upload of logos, favicons and configuration of theme colours | | Mail | Mail out name and address | | Footer | Configure links legal information (privacy policy, imprint) in footer | | Accounts | Configure primary group match regex and fields on person model that should be editable by themselves| | School | Official and display name of your school | | Authentication | Enable/disable sign up, allow users to change their password | | Internationalisation | Configure available languages |

en	### User preferences

en	| Section | Purpose | |---------------|--------------------------------------------------| | Notifications | Configure notifications channels and name format |

en	## Caching

en	### Redis

en	Redis cache can be managed via `redis-cli` on the command line:

en	```shell # Flush all objects from cache 127.0.0.1:6379> FLUSHALL ```

en	## Global search

en	AlekSIS provides a global search in the left navigation bar. You are able to search through former indexed persons and groups.

en	Other apps can also add their models to the index.

en	### Manage indexes

en	Items in indexes are updated automatically by their save-hooks.

en	Indexes can also be managed via `aleksis-admin` on the command line:

en	```shell # Clear all objects from the index $ aleksis-admin clear_index # Show indexes $ aleksis-admin haystack_info # Rebuild all indexes $ aleksis-admin rebuild_index # Update item on index $ aleksis-admin update_index <App label> ```

en	# Monitoring and health checks {#sec:Monitoring}

en	## Configuration

en	### Thresholds

en	Thresholds for health checks can be configured via config file (`/etc/aleksis`).

en	```toml [health] disk_usage_max_percent = 90 memory_min_mb = 500

en	[backup.database] check_seconds = 7200

en	[backup.media] check_seconds = 7200 ```

en	## Status page

en	AlekSIS status page show information about the health of your AlekSIS instance. You can visit it via the left navigation bar (Admin → Status).

en	The page show information about debug and maintenance mode, a summary of your health checks and the last exit status of your celery tasks. This page can not be used as a health check, it will always return HTTP 200 if the site is reachable.

en	## Health check

en	The health check can be used to verify the health of your AlekSIS instance. You can access it via the browser (https://aleksis.example.com/health/) and it will show you a summary of your health checks. If something is wrong it will return HTTP 500.

en	It is also possible to get a JSON response from the health check, for example via `curl`. You only have to pass a valid `Accept: application/json` header to your request.

en	The health check can also be executed via `aleksis-admin`:

en	```shell $ aleksis-admin health_check ```

en	## Monitoring with Icinga2

en	As already mentioned, there is a JSON endpoint at https://aleksis.example.com/health/. You can use an json check plugin to check seperate health checks or just use a HTTP check to check if the site returns HTTP 200.

en	## Performance monitoring with Prometheus

en	AlekSIS provides a Prometheus exporter. The exporter provides metrics about responses and requests, e.g. s about response codes, request latency and requests per view. It al provides data about database operations.

en	### Metrics endpoint

en	The metrics endpoint can be found at https://aleksis.example.com/metrics. In the default configuration it can be scraped from everywhere. You might want to add some webserver configuration to restrict access to this url.

en	To get metrics of your AlekSIS instance, just add the following to `prometheus.yml`

en	```yaml - job_name: aleksis static_configs: - targets: ['my.aleksis-instance.com'] metrics_path: /metrics ```

en	### Rules for prometheus alertmanager

en	If you are using the prometheus alertmanager, it is possible to create some alerting rules so that an alert is fired when your AlekSIS instance is slow or something.

en	```yaml groups: - name: aleksis rules: - alert: HighRequestLatency expr: histogram_quantile(0.999, sum(rate(django_http_requests_latency_seconds_by_view_method_bucket{instance="YOUR-INSTANCE",view!~"prometheus-django-metrics|healthcheck"}[15m])) by (job, le)) < 30 for: 15m labels: severity: page annotations: summary: High request latency for 15 minutes ```

en	### Grafana dashboard

en	There is a Grafana dashboard available to visualize the metrics.

en	The dashboard is available at https://grafana.com/grafana/dashboards/9528.

en	## Managing your personal account

en	Each logged in user has several options to provided through the AlekSIS core. Which of these items are display depends on whether the user has a person and what your system administrator has configured.

en	### Notifications {#sec:Notifications} The AlekSIS core has a built-in notification system which can be used by apps to send urgent information to specific persons (e. g. timetable changes). Notifications are shown on the dashboard and the notifications page reachable over the menu entry `Notifications`. In addition to that, notifications can be sent to users through several communication channels. These channels can be switched on or off in your personal preferences (cf. [@sec:PersonalPreferences]).

en	### Setup two-factor authentication TBA.

en	### Change password

en	If your system administrator has activated this function, you can change your password via `Account → Change password`. If you forgot your password, there is a link `Password forgotten?` on this page which helps with resetting your password. The system then will send you a password reset link via email.

en	### Me page

en	Reachable under `Account → Me`, this page shows the personal information saved about you in the system. If activated, you can upload a picture of yourself or edit some information.

en	### Personal preferences {#sec:PersonalPreferences}

en	You can configure some behavior using the preferences under `Account → Preferences`. By default, the Core only provides some preferences, but apps can extend this list. You can find further information about such preferences in the chapter of the respective apps.

en	**Notifications**

en	**Name format for addressing**: Here you can select how AlekSIS should address you.

en	**Channels to use for notifications:** This channel is used to sent notifications to you (cf. [@sec:Notifications]).

en	### Third-party accounts If you logged in using a third-party account (e. g. a Google or Microsoft account), you can manage the connections to these accounts on the page `Account → Third-party accounts`.

en	### Authorized applications On the page `Account → Authorized applications` you can see all external applications you authorized to retreive data about you from AlekSIS. That can be services provided by your local institution like a chat platform, for example.

en	# Integrations with other software {#sec:Integrations}

en	TBA.

en	# Developing apps and extending AlekSIS

en	# Appendices

en	## Free Software and Open Source {#sec:FOSS}

en	## Legal information {#sec:Leagl}

en	## Copyright Notes

en	### AlekSIS Core and official apps

en	The AlekSIS Core and all official apps are copyright by the respective developers, as listed in the text files accompanying each source tree. They are licensed under the terms of the European Union Public License (EUPL), version 1.2 or later.

en	### The AlekSIS Handbook

en	This handbook itself, with the exception of the cover artwork, is copyright 2021 by the authors listed on the cover, and licensed under the EUPL, version 1.2 or later.

en	### Cover artwork

en	The cover artwork remix is copyright 2021 by Dominik George.

en	The following cover artwork photos are copyright 2021 by Max Knopp of Katharineum zu Lübeck:

en	Children in front of digital signage monitor

en	Child's hand with smartphone

en	Teachers in front of computer screen

en	The following cover artwork photo is copyright 2020 Martin Gummi of Teckids e.V.:

en	People in computer lab with laptops

en	All artwork is licensed under EUPL 1.2 or later or, optionally, under CC-BY-SA 4.0 or later.

en	## EUROPEAN UNION PUBLIC LICENCE v. 1.2

en	EUPL © the European Union 2007, 2016

en	This European Union Public Licence (the 'EUPL') applies to the Work (as defined below) which is provided under the terms of this Licence. Any use of the Work, other than as authorised under this Licence is prohibited (to the extent such use is covered by a right of the copyright holder of the Work).

en	The Work is provided under the terms of this Licence when the Licensor (as defined below) has placed the following notice immediately following the copyright notice for the Work:

en	> Licensed under the EUPL

en	or has expressed by any other means his willingness to license under the EUPL.

en	### Definitions

en	### 1. Definitions

en	In this Licence, the following terms have the following meaning:

en	'The Licence': this Licence.

en	'The Original Work': the work or software distributed or communicated by the Licensor under this Licence, available as Source Code and also as Executable Code as the case may be.

en	'Derivative Works': the works or software that could be created by the Licensee, based upon the Original Work or modifications thereof. This Licence does not define the extent of modification or dependence on the Original Work required in order to classify a work as a Derivative Work; this extent is determined by copyright law applicable in the country mentioned in Article 15.

en	'The Work': the Original Work or its Derivative Works.

en	'The Source Code': the human-readable form of the Work which is the most convenient for people to study and modify.

en	'The Executable Code': any code which has generally been compiled and which is meant to be interpreted by a computer as a program.

en	'The Licensor': the natural or legal person that distributes or communicates the Work under the Licence.

en	'Contributor(s)': any natural or legal person who modifies the Work under the Licence, or otherwise contributes to the creation of a Derivative Work.

en	'The Licensee' or 'You': any natural or legal person who makes any usage of the Work under the terms of the Licence.

en	'Distribution' or 'Communication': any act of selling, giving, lending, renting, distributing, communicating, transmitting, or otherwise making available, online or offline, copies of the Work or providing access to its essential functionalities at the disposal of any other natural or legal person.

en	### Scope of the rights granted by the Licence

en	The Licensor hereby grants You a worldwide, royalty-free, non-exclusive, sublicensable licence to do the following, for the duration of copyright vested in the Original Work:

en	use the Work in any circumstance and for all usage,

en	reproduce the Work,

en	modify the Work, and make Derivative Works based upon the Work,

en	communicate to the public, including the right to make available or display the Work or copies thereof to the public and perform publicly, as the case may be, the Work,

en	distribute the Work or copies thereof,

en	lend and rent the Work or copies thereof,

en	sublicense rights in the Work or copies thereof.

en	Those rights can be exercised on any media, supports and formats, whether now known or later invented, as far as the applicable law permits so.

en	In the countries where moral rights apply, the Licensor waives his right to exercise his moral right to the extent allowed by law in order to make effective the licence of the economic rights here above listed.

en	The Licensor grants to the Licensee royalty-free, non-exclusive usage rights to any patents held by the Licensor, to the extent necessary to make use of the rights granted on the Work under this Licence.

en	### Communication of the Source Code

en	The Licensor may provide the Work either in its Source Code form, or as Executable Code. If the Work is provided as Executable Code, the Licensor provides in addition a machine-readable copy of the Source Code of the Work along with each copy of the Work that the Licensor distributes or indicates, in a notice following the copyright notice attached to the Work, a repository where the Source Code is easily and freely accessible for as long as the Licensor continues to distribute or communicate the Work.

en	### Limitations on copyright

en	Nothing in this Licence is intended to deprive the Licensee of the benefits from any exception or limitation to the exclusive rights of the rights owners in the Work, of the exhaustion of those rights or of other applicable limitations thereto.

en	### Obligations of the Licensee

en	The grant of the rights mentioned above is subject to some restrictions and obligations imposed on the Licensee. Those obligations are the following:

en	*Attribution right*: The Licensee shall keep intact all copyright, patent or trademarks notices and all notices that refer to the Licence and to the disclaimer of warranties. The Licensee must include a copy of such notices and a copy of the Licence with every copy of the Work he/she distributes or communicates. The Licensee must cause any Derivative Work to carry prominent notices stating that the Work has been modified and the date of modification.

en	*Copyleft clause*: If the Licensee distributes or communicates copies of the Original Works or Derivative Works, this Distribution or Communication will be done under the terms of this Licence or of a later version of this Licence unless the Original Work is expressly distributed only under this version of the Licence --- for example by communicating 'EUPL v. 1.2 only'. The Licensee (becoming Licensor) cannot offer or impose any additional terms or conditions on the Work or Derivative Work that alter or restrict the terms of the Licence.

en	*Compatibility clause*: If the Licensee Distributes or Communicates Derivative Works or copies thereof based upon both the Work and another work licensed under a Compatible Licence, this Distribution or Communication can be done under the terms of this Compatible Licence. For the sake of this clause, 'Compatible Licence' refers to the licences listed in the appendix attached to this Licence. Should the Licensee's obligations under the Compatible Licence conflict with his/her obligations under this Licence, the obligations of the Compatible Licence shall prevail.

en	*Provision of Source Code*: When distributing or communicating copies of the Work, the Licensee will provide a machine-readable copy of the Source Code or indicate a repository where this Source will be easily and freely available for as long as the Licensee continues to distribute or communicate the Work. Legal Protection: This Licence does not grant permission to use the trade names, trademarks, service marks, or names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the copyright notice.

en	### Chain of Authorship

en	The original Licensor warrants that the copyright in the Original Work granted hereunder is owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.

en	Each Contributor warrants that the copyright in the modifications he/she brings to the Work are owned by him/her or licensed to him/her and that he/she has the power and authority to grant the Licence.

en	Each time You accept the Licence, the original Licensor and subsequent Contributors grant You a licence to their contributions to the Work, under the terms of this Licence.

en	### Disclaimer of Warranty

en	The Work is a work in progress, which is continuously improved by numerous Contributors. It is not a finished work and may therefore contain defects or 'bugs' inherent to this type of development. For the above reason, the Work is provided under the Licence on an 'as is' basis and without warranties of any kind concerning the Work, including without limitation merchantability, fitness for a particular purpose, absence of defects or errors, accuracy, non-infringement of intellectual property rights other than copyright as stated in Article 6 of this Licence.

en	This disclaimer of warranty is an essential part of the Licence and a condition for the grant of any rights to the Work.

en	### Disclaimer of Liability

en	Except in the cases of wilful misconduct or damages directly caused to natural persons, the Licensor will in no event be liable for any direct or indirect, material or moral, damages of any kind, arising out of the Licence or of the use of the Work, including without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, loss of data or any commercial damage, even if the Licensor has been advised of the possibility of such damage. However, the Licensor will be liable under statutory product liability laws as far such laws apply to the Work.

en	### 9. Additional agreements

en	While distributing the Work, You may choose to conclude an additional agreement, defining obligations or services consistent with this Licence. However, if accepting obligations, You may act only on your own behalf and on your sole responsibility, not on behalf of the original Licensor or any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against such Contributor by the fact You have accepted any warranty or additional liability.

en	### Acceptance of the Licence

en	The provisions of this Licence can be accepted by clicking on an icon 'I agree' placed under the bottom of a window displaying the text of this Licence or by affirming consent in any other similar way, in accordance with the rules of applicable law. Clicking on that icon indicates your clear and irrevocable acceptance of this Licence and all of its terms and conditions.

en	Similarly, you irrevocably accept this Licence and all of its terms and conditions by exercising any rights granted to You by Article 2 of this Licence, such as the use of the Work, the creation by You of a Derivative Work or the Distribution or Communication by You of the Work or copies thereof.

en	### Information to the public

en	In case of any Distribution or Communication of the Work by means of electronic communication by You (for example, by offering to download the Work from a remote location) the distribution channel or media (for example, a website) must at least provide to the public the information requested by the applicable law regarding the Licensor, the Licence and the way it may be accessible, concluded, stored and reproduced by the Licensee.

en	### Termination of the Licence

en	The Licence and the rights granted hereunder will terminate automatically upon any breach by the Licensee of the terms of the Licence.

en	Such a termination will not terminate the licences of any person who has received the Work from the Licensee under the Licence, provided such persons remain in full compliance with the Licence.

en	### Miscellaneous

en	Without prejudice of Article 9 above, the Licence represents the complete agreement between the Parties as to the Work.

en	If any provision of the Licence is invalid or unenforceable under applicable law, this will not affect the validity or enforceability of the Licence as a whole. Such provision will be construed or reformed so as necessary to make it valid and enforceable.

en	The European Commission may publish other linguistic versions or new versions of this Licence or updated versions of the Appendix, so far this is required and reasonable, without reducing the scope of the rights granted by the Licence.

en	New versions of the Licence will be published with a unique version number.

en	All linguistic versions of this Licence, approved by the European Commission, have identical value. Parties can take advantage of the linguistic version of their choice.

en	### Jurisdiction

en	Without prejudice to specific agreement between parties,

en	any litigation resulting from the interpretation of this License, arising between the European Union institutions, bodies, offices or agencies, as a Licensor, and any Licensee, will be subject to the jurisdiction of the Court of Justice of the European Union, as laid down in article 272 of the Treaty on the Functioning of the European Union,

en	any litigation arising between other parties and resulting from the interpretation of this License, will be subject to the exclusive jurisdiction of the competent court where the Licensor resides or conducts its primary business.

en	### Applicable Law

en	this Licence shall be governed by the law of the European Union Member State where the Licensor has his seat, resides or has his registered office,

en	this licence shall be governed by Belgian law if the Licensor has no seat, residence or registered office inside a European Union Member State.

en	### Appendix

en	'Compatible Licences' according to Article 5 EUPL are:

en	GNU General Public License (GPL) v. 2, v. 3

en	GNU Affero General Public License (AGPL) v. 3

en	Open Software License (OSL) v. 2.1, v. 3.0

en	Eclipse Public License (EPL) v. 1.0

en	CeCILL v. 2.0, v. 2.1

en	Mozilla Public Licence (MPL) v. 2

en	GNU Lesser General Public Licence (LGPL) v. 2.1, v. 3

en	Creative Commons Attribution-ShareAlike v. 3.0 Unported (CC BY-SA 3.0) for works other than software

en	European Union Public Licence (EUPL) v. 1.1, v. 1.2

en	Québec Free and Open-Source Licence --- Reciprocity (LiLiQ-R) or Strong Reciprocity (LiLiQ-R+)

en	The European Commission may update this Appendix to later versions of the above licences without producing a new version of the EUPL, as long as they provide the rights granted in Article 2 of this Licence and protect the covered Source Code from exclusive appropriation.

en	All other changes or additions to this Appendix require the production of a new EUPL version.