imports for tests

Updates for project Alliance Auth

See merge request allianceauth/allianceauth!1764

.coveragerc

@@ -19,5 +19,6 @@ exclude_lines =
     if __name__ == .__main__.:
     def __repr__
     raise AssertionError
+    if TYPE_CHECKING:
 
 ignore_errors = True

.git-blame-ignore-revs

@@ -0,0 +1,6 @@
+# git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+
+
+# Ruff initial formatting storm
+a99315ea55339f0b6010b5c9d8703e51278fcf29

.gitignore

@@ -69,11 +69,9 @@ celerybeat-schedule
 #gitlab configs
 .gitlab/
 
-#transifex
-.tx/
-
 #other
 .flake8
+.ruff_cache
 .pylintrc
 Makefile
-.isort.cfg
+alliance_auth.sqlite3

.gitlab-ci.yml

@@ -5,15 +5,16 @@
     - merge_requests
 
 stages:
-- pre-commit
-- gitlab
-- test
-- deploy
-- docker
+  - pre-commit
+  - gitlab
+  - test
+  - deploy
+  - docker
 
 include:
-- template: Dependency-Scanning.gitlab-ci.yml
-- template: Security/SAST.gitlab-ci.yml
+  - template: Dependency-Scanning.gitlab-ci.yml
+  - template: Security/SAST.gitlab-ci.yml
+  - template: Security/Secret-Detection.gitlab-ci.yml
 
 before_script:
   - apt-get update && apt-get install redis-server -y
@@ -24,12 +25,12 @@ before_script:
 pre-commit-check:
   <<: *only-default
   stage: pre-commit
-  image: python:3.6-buster
-  variables:
-    PRE_COMMIT_HOME: ${CI_PROJECT_DIR}/.cache/pre-commit
-  cache:
-    paths:
-      - ${PRE_COMMIT_HOME}
+  image: python:3.11-trixie
+  # variables:
+  #   PRE_COMMIT_HOME: ${CI_PROJECT_DIR}/.cache/pre-commit
+  # cache:
+  #   paths:
+  #     - ${PRE_COMMIT_HOME}
   script:
     - pip install pre-commit
     - pre-commit run --all-files
@@ -41,52 +42,20 @@ sast:
 dependency_scanning:
   stage: gitlab
   before_script:
-  - apt-get update && apt-get install redis-server libmariadb-dev -y
-  - redis-server --daemonize yes
-  - python -V
-  - pip install wheel tox
+    - apt-get update && apt-get install redis-server libmariadb-dev -y
+    - redis-server --daemonize yes
+    - python -V
+    - pip install wheel tox
 
-test-3.7-core:
-  <<: *only-default
-  image: python:3.7-bullseye
-  script:
-  - tox -e py37-core
-  artifacts:
-    when: always
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-
-test-3.8-core:
-  <<: *only-default
-  image: python:3.8-bullseye
-  script:
-  - tox -e py38-core
-  artifacts:
-    when: always
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-
-test-3.9-core:
-  <<: *only-default
-  image: python:3.9-bullseye
-  script:
-  - tox -e py39-core
-  artifacts:
-    when: always
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
+secret_detection:
+  stage: gitlab
+  before_script: []
 
 test-3.10-core:
   <<: *only-default
-  image: python:3.10-bullseye
+  image: python:3.10-trixie
   script:
-  - tox -e py310-core
+    - tox -e py310-core
   artifacts:
     when: always
     reports:
@@ -96,22 +65,9 @@ test-3.10-core:
 
 test-3.11-core:
   <<: *only-default
-  image: python:3.11-rc-bullseye
+  image: python:3.11-trixie
   script:
-  - tox -e py311-core
-  artifacts:
-    when: always
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-  allow_failure: true
-
-test-3.7-all:
-  <<: *only-default
-  image: python:3.7-bullseye
-  script:
-  - tox -e py37-all
+    - tox -e py311-core
   artifacts:
     when: always
     reports:
@@ -119,11 +75,11 @@ test-3.7-all:
         coverage_format: cobertura
         path: coverage.xml
 
-test-3.8-all:
+test-3.12-core:
   <<: *only-default
-  image: python:3.8-bullseye
+  image: python:3.12-trixie
   script:
-  - tox -e py38-all
+    - tox -e py312-core
   artifacts:
     when: always
     reports:
@@ -131,11 +87,23 @@ test-3.8-all:
         coverage_format: cobertura
         path: coverage.xml
 
-test-3.9-all:
+test-3.13-core:
   <<: *only-default
-  image: python:3.9-bullseye
+  image: python:3.13-trixie
   script:
-  - tox -e py39-all
+    - tox -e py313-core
+  artifacts:
+    when: always
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+test-3.14-core:
+  <<: *only-default
+  image: python:3.14-trixie
+  script:
+    - tox -e py314-core
   artifacts:
     when: always
     reports:
@@ -145,9 +113,9 @@ test-3.9-all:
 
 test-3.10-all:
   <<: *only-default
-  image: python:3.10-bullseye
+  image: python:3.10-trixie
   script:
-  - tox -e py310-all
+    - tox -e py310-all
   artifacts:
     when: always
     reports:
@@ -157,43 +125,100 @@ test-3.10-all:
 
 test-3.11-all:
   <<: *only-default
-  image: python:3.11-rc-bullseye
+  image: python:3.11-trixie
   script:
-  - tox -e py311-all
+    - tox -e py311-all
   artifacts:
     when: always
     reports:
       coverage_report:
         coverage_format: cobertura
         path: coverage.xml
-  allow_failure: true
+  coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
+
+test-3.12-all:
+  <<: *only-default
+  image: python:3.12-trixie
+  script:
+    - tox -e py312-all
+  artifacts:
+    when: always
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+test-3.13-all:
+  <<: *only-default
+  image: python:3.13-trixie
+  script:
+    - tox -e py313-all
+  artifacts:
+    when: always
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+test-3.14-all:
+  <<: *only-default
+  image: python:3.14-trixie
+  script:
+    - tox -e py314-all
+  artifacts:
+    when: always
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+build-test:
+  stage: test
+  image: python:3.12-trixie
+
+  before_script:
+    - python -m pip install --upgrade pip
+    - python -m pip install --upgrade build
+    - python -m pip install --upgrade setuptools wheel
+
+  script:
+    - python -m build
+
+  artifacts:
+    when: always
+    name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
+    paths:
+      - dist/*
+    expire_in: 1 year
 
 test-docs:
   <<: *only-default
-  image: python:3.9-bullseye
+  image: python:3.12-trixie
   script:
-  - tox -e docs
+    - tox -e docs
 
 deploy_production:
   stage: deploy
-  image: python:3.10-bullseye
+  image: python:3.12-trixie
 
   before_script:
-    - pip install twine wheel
+    - python -m pip install --upgrade pip
+    - python -m pip install --upgrade build
+    - python -m pip install --upgrade setuptools wheel twine
 
   script:
-    - python setup.py sdist bdist_wheel
-    - twine upload dist/*
+    - python -m build
+    - python -m twine upload dist/*
 
   rules:
     - if: $CI_COMMIT_TAG
 
 build-image:
   before_script: []
-  image: docker:20.10.10
+  image: docker:27
   stage: docker
   services:
-    - docker:20.10.10-dind
+    - docker:27-dind
   script: |
     CURRENT_DATE=$(echo $CI_COMMIT_TIMESTAMP | head -c 10 | tr -d -)
     IMAGE_TAG=$CI_REGISTRY_IMAGE/auth:$CURRENT_DATE-$CI_COMMIT_SHORT_SHA
@@ -203,28 +228,30 @@ build-image:
     LATEST_TAG=$CI_REGISTRY_IMAGE/auth:latest
 
     docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-    docker build . -t $IMAGE_TAG -f docker/Dockerfile --build-arg AUTH_VERSION=$(echo $CI_COMMIT_TAG | cut -c 2-)
-    docker tag $IMAGE_TAG $CURRENT_TAG
-    docker tag $IMAGE_TAG $MINOR_TAG
-    docker tag $IMAGE_TAG $MAJOR_TAG
-    docker tag $IMAGE_TAG $LATEST_TAG
-    docker image push --all-tags $CI_REGISTRY_IMAGE/auth
+    docker run --privileged --rm tonistiigi/binfmt --uninstall qemu-*
+    docker run --privileged --rm tonistiigi/binfmt --install all
+    docker buildx create --use --name new-builder
+    docker buildx build . --tag $IMAGE_TAG --tag $CURRENT_TAG --tag $MINOR_TAG --tag $MAJOR_TAG --tag $LATEST_TAG --file docker/Dockerfile --platform linux/amd64,linux/arm64 --push --build-arg AUTH_VERSION=$(echo $CI_COMMIT_TAG | cut -c 2-)
   rules:
     - if: $CI_COMMIT_TAG
+      when: delayed
+      start_in: 10 minutes
 
 build-image-dev:
   before_script: []
-  image: docker:20.10.10
+  image: docker:27
   stage: docker
   services:
-    - docker:20.10.10-dind
+    - docker:27-dind
   script: |
     CURRENT_DATE=$(echo $CI_COMMIT_TIMESTAMP | head -c 10 | tr -d -)
     IMAGE_TAG=$CI_REGISTRY_IMAGE/auth:$CURRENT_DATE-$CI_COMMIT_BRANCH-$CI_COMMIT_SHORT_SHA
 
     docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-    docker build . -t $IMAGE_TAG -f docker/Dockerfile --build-arg AUTH_PACKAGE=git+https://gitlab.com/allianceauth/allianceauth@$CI_COMMIT_BRANCH
-    docker push $IMAGE_TAG
+    docker run --privileged --rm tonistiigi/binfmt --uninstall qemu-*
+    docker run --privileged --rm tonistiigi/binfmt --install all
+    docker buildx create --use --name new-builder
+    docker buildx build . --tag $IMAGE_TAG --file docker/Dockerfile --platform linux/amd64,linux/arm64 --push --build-arg AUTH_PACKAGE=git+https://gitlab.com/allianceauth/allianceauth@$CI_COMMIT_BRANCH
   rules:
     - if: '$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME == ""'
       when: manual
@@ -233,17 +260,19 @@ build-image-dev:
 
 build-image-mr:
   before_script: []
-  image: docker:20.10.10
+  image: docker:27
   stage: docker
   services:
-    - docker:20.10.10-dind
+    - docker:27-dind
   script: |
     CURRENT_DATE=$(echo $CI_COMMIT_TIMESTAMP | head -c 10 | tr -d -)
     IMAGE_TAG=$CI_REGISTRY_IMAGE/auth:$CURRENT_DATE-$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME-$CI_COMMIT_SHORT_SHA
 
     docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-    docker build . -t $IMAGE_TAG -f docker/Dockerfile --build-arg AUTH_PACKAGE=git+$CI_MERGE_REQUEST_SOURCE_PROJECT_URL@$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME
-    docker push $IMAGE_TAG
+    docker run --privileged --rm tonistiigi/binfmt --uninstall qemu-*
+    docker run --privileged --rm tonistiigi/binfmt --install all
+    docker buildx create --use --name new-builder
+    docker buildx build . --tag $IMAGE_TAG --file docker/Dockerfile --platform linux/amd64,linux/arm64 --push --build-arg AUTH_PACKAGE=git+$CI_MERGE_REQUEST_SOURCE_PROJECT_URL@$CI_MERGE_REQUEST_SOURCE_BRANCH_NAME
   rules:
     - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
       when: manual

.pre-commit-config.yaml

@@ -3,32 +3,89 @@
 # Update this file:
 #   pre-commit autoupdate
 
+# Set the default language versions for the hooks
+default_language_version:
+  python: python3  # Force all Python hooks to use Python 3
+  node: 22.12.0  # Force all Node hooks to use Node 22.12.0
+
+# Globally exclude files
+# https://pre-commit.com/#top_level-exclude
+exclude: |
+  (?x)(
+    LICENSE|
+    allianceauth\/static\/allianceauth\/css\/themes\/bootstrap-locals.less|
+    \.min\.css|
+    \.min\.js|
+    \.po|
+    \.mo|
+    swagger\.json|
+    static/(.*)/libs/|
+    telnetlib\.py
+  )
+
 repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.0.1
+  # Code Upgrades
+  - repo: https://github.com/adamchainz/django-upgrade
+    rev: 1.29.0
     hooks:
-      - id: check-case-conflict
-      - id: check-json
-      - id: check-xml
-      - id: check-yaml
-      - id: fix-byte-order-marker
-      - id: trailing-whitespace
-        exclude: (\.min\.css|\.min\.js|\.mo|\.po|swagger\.json)$
-      - id: end-of-file-fixer
-        exclude: (\.min\.css|\.min\.js|\.mo|\.po|swagger\.json)$
-      - id: mixed-line-ending
-        args: [ '--fix=lf' ]
-      - id: fix-encoding-pragma
-        args: [ '--remove' ]
-
-  - repo: https://github.com/editorconfig-checker/editorconfig-checker.python
-    rev: 2.3.54
-    hooks:
-      - id: editorconfig-checker
-        exclude: ^(LICENSE|allianceauth\/static\/css\/themes\/bootstrap-locals.less|allianceauth\/eveonline\/swagger.json|(.*.po)|(.*.mo))
-
+      - id: django-upgrade
+        args: [--target-version=5.2]
   - repo: https://github.com/asottile/pyupgrade
-    rev: v2.29.0
+    rev: v3.20.0
     hooks:
       - id: pyupgrade
-        args: [ --py37-plus ]
+        args: [--py310-plus]
+
+  # Formatting
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      # Identify invalid files
+      - id: check-ast
+      - id: check-yaml
+      - id: check-json
+      - id: check-toml
+      - id: check-xml
+      # git checks
+      - id: check-merge-conflict
+      - id: check-added-large-files
+        args: [--maxkb=1000]
+      - id: detect-private-key
+      - id: check-case-conflict
+      # Python checks
+#      - id: check-docstring-first
+      - id: debug-statements
+#      - id: requirements-txt-fixer
+      - id: fix-byte-order-marker
+      # General quality checks
+      - id: mixed-line-ending
+        args: [--fix=lf]
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+      - id: check-executables-have-shebangs
+      - id: end-of-file-fixer
+  - repo: https://github.com/editorconfig-checker/editorconfig-checker.python
+    rev: 3.4.0
+    hooks:
+      - id: editorconfig-checker
+  - repo: https://github.com/igorshubovych/markdownlint-cli
+    rev: v0.45.0
+    hooks:
+      - id: markdownlint
+        language: node
+        args:
+          - --disable=MD013
+
+  # Infrastructure
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: v2.11.0
+    hooks:
+      - id: pyproject-fmt
+        args:
+          - --indent=4
+        additional_dependencies:
+          - tox==4.32.0 # https://github.com/tox-dev/tox/releases/latest
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.24.1
+    hooks:
+      - id: validate-pyproject

.readthedocs.yml

@@ -5,19 +5,28 @@
 # Required
 version: 2
 
+# Set the version of Python and other tools you might need
+build:
+  os: ubuntu-24.04
+  apt_packages:
+    - redis
+  tools:
+    python: "3.12"
+  jobs:
+    post_system_dependencies:
+      - redis-server --daemonize yes
+
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
   configuration: docs/conf.py
 
-# Build documentation with MkDocs
-#mkdocs:
-#  configuration: mkdocs.yml
-
 # Optionally build your docs in additional formats such as PDF and ePub
 formats: all
 
-# Optionally set the version of Python and requirements required to build your docs
+# Python requirements required to build your docs
 python:
-  version: 3.7
   install:
-    - requirements: docs/requirements.txt
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs

.tx/transifex.yml

@@ -0,0 +1,10 @@
+filters:
+  - filter_type: file
+    file_format: PO
+    source_file: allianceauth/locale/en/LC_MESSAGES/django.po
+    source_language: en
+    translation_files_expression: allianceauth/locale/<lang>/LC_MESSAGES/django.po
+
+settings:
+  language_mapping:
+    zh-Hans: zh_Hans

CODEOWNERS

@@ -0,0 +1 @@
+* @allianceauth

MANIFEST.in

@@ -1,7 +0,0 @@
-include LICENSE
-include README.md
-include MANIFEST.in
-graft allianceauth
-
-global-exclude __pycache__
-global-exclude *.py[co]

README.md

@@ -1,50 +1,56 @@
 # Alliance Auth
 
-[![license](https://img.shields.io/badge/license-GPLv2-green)](https://pypi.org/project/allianceauth/)
-[![python](https://img.shields.io/pypi/pyversions/allianceauth)](https://pypi.org/project/allianceauth/)
-[![django](https://img.shields.io/pypi/djversions/allianceauth?label=django)](https://pypi.org/project/allianceauth/)
-[![version](https://img.shields.io/pypi/v/allianceauth?label=release)](https://pypi.org/project/allianceauth/)
-[![pipeline status](https://gitlab.com/allianceauth/allianceauth/badges/master/pipeline.svg)](https://gitlab.com/allianceauth/allianceauth/commits/master)
-[![Documentation Status](https://readthedocs.org/projects/allianceauth/badge/?version=latest)](http://allianceauth.readthedocs.io/?badge=latest)
-[![coverage report](https://gitlab.com/allianceauth/allianceauth/badges/master/coverage.svg)](https://gitlab.com/allianceauth/allianceauth/commits/master)
+[![License](https://img.shields.io/badge/license-GPLv2-green)](https://pypi.org/project/allianceauth/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/allianceauth)](https://pypi.org/project/allianceauth/)
+[![Django Versions](https://img.shields.io/pypi/djversions/allianceauth?label=django)](https://pypi.org/project/allianceauth/)
+[![Stable AA Version](https://img.shields.io/pypi/v/allianceauth?label=release)](https://pypi.org/project/allianceauth/)
+[![Pipeline Status](https://gitlab.com/allianceauth/allianceauth/badges/master/pipeline.svg)](https://gitlab.com/allianceauth/allianceauth/commits/master)
+[![Documentation Status](https://readthedocs.org/projects/allianceauth/badge/?version=latest)](https://allianceauth.readthedocs.io/?badge=latest)
+[![Test Coverage Report](https://gitlab.com/allianceauth/allianceauth/badges/master/coverage.svg)](https://gitlab.com/allianceauth/allianceauth/commits/master)
 [![Chat on Discord](https://img.shields.io/discord/399006117012832262.svg)](https://discord.gg/fjnHAmk)
 
-An auth system for EVE Online to help in-game organizations manage online service access.
+A flexible authentication platform for EVE Online to help in-game organizations manage access to applications and services. AA provides both, a stable core, and a robust framework for community development and custom applications.
 
 ## Content
 
 - [Overview](#overview)
-- [Documentation](http://allianceauth.rtfd.io)
+- [Documentation](https://allianceauth.rtfd.io)
 - [Support](#support)
 - [Release Notes](https://gitlab.com/allianceauth/allianceauth/-/releases)
-- [Developer Team](#developer-team)
+- [Developer Team](#development-team)
 - [Contributing](#contributing)
 
 ## Overview
 
-Alliance Auth (AA) is a web site that helps Eve Online organizations efficiently manage access to applications and services.
+Alliance Auth (AA) is a platform that helps Eve Online organizations efficiently manage access to applications and services.
 
 Main features:
 
-- Automatically grants or revokes user access to external services (e.g. Discord, Mumble) and web apps (e.g. SRP requests) based on the user's current membership to [in-game organizations](https://allianceauth.readthedocs.io/en/latest/features/core/states/) and [groups](https://allianceauth.readthedocs.io/en/latest/features/core/groups/)
+- Automatically grants or revokes user access to external services (e.g.: Discord, Mumble) based on the user's current membership to [a variety of EVE Online affiliation](https://allianceauth.readthedocs.io/en/latest/features/core/states/) and [groups](https://allianceauth.readthedocs.io/en/latest/features/core/groups/)
 
 - Provides a central web site where users can directly access web apps (e.g. SRP requests, Fleet Schedule) and manage their access to external services and groups.
 
-- Includes a set of connectors (called ["services"](https://allianceauth.readthedocs.io/en/latest/features/services/)) for integrating access management with many popular external applications / services like Discord, Mumble, Teamspeak 3, SMF and others
+- Includes a set of connectors (called ["Services"](https://allianceauth.readthedocs.io/en/latest/features/services/)) for integrating access management with many popular external applications / services like Discord, Mumble, Teamspeak 3, SMF and others
 
-- Includes a set of web [apps](https://allianceauth.readthedocs.io/en/latest/features/apps/) which add many useful functions, e.g.: fleet schedule, timer board, SRP request management, fleet activity tracker
+- Includes a set of web [Apps](https://allianceauth.readthedocs.io/en/latest/features/apps/) which add many useful functions, e.g.: fleet schedule, timer board, SRP request management, fleet activity tracker
 
 - Can be easily extended with additional services and apps. Many are provided by the community and can be found here: [Community Creations](https://gitlab.com/allianceauth/community-creations)
 
-- English :flag_gb:, Chinese :flag_cn:, German :flag_de:, Spanish :flag_es:, Korean :flag_kr: and Russian :flag_ru: localization
+- English :flag_gb:, Chinese :flag_cn:, German :flag_de:, Spanish :flag_es:, Korean :flag_kr:, Russian :flag_ru:, Italian :flag_it:, French :flag_fr:, Japanese :flag_jp: and Ukrainian :flag_ua: Localization
 
-For further details about AA - including an installation guide and a full list of included services and plugin apps - please see the [official documentation](http://allianceauth.rtfd.io).
+For further details about AA - including an installation guide and a full list of included services and plugin apps - please see the [official documentation](https://allianceauth.rtfd.io).
 
 ## Screenshot
 
-Here is an example of the Alliance Auth web site with some plug-ins apps and services enabled:
+Here is an example of the Alliance Auth web site with a mixture of Services, Apps and Community Creations enabled:
 
-![screenshot](https://i.imgur.com/2tnX9kD.png)
+### Flatly Theme
+
+![Flatly Theme](docs/_static/images/promotion/SampleInstallation-Flatly.png)
+
+### Darkly Theme
+
+![Darkly Theme](docs/_static/images/promotion/SampleInstallation-Darkly.png)
 
 ## Support
 
@@ -56,13 +62,15 @@ Here is an example of the Alliance Auth web site with some plug-ins apps and ser
 
 - [Aaron Kable](https://gitlab.com/aaronkable/)
 - [Ariel Rin](https://gitlab.com/soratidus999/)
-- [Basraah](https://gitlab.com/basraah/)
 - [Col Crunch](https://gitlab.com/colcrunch/)
 - [Erik Kalkoken](https://gitlab.com/ErikKalkoken/)
+- [Rounon Dax](https://gitlab.com/ppfeufer)
+- [snipereagle1](https://gitlab.com/mckernanin)
 
 ### Former Developers
 
 - [Adarnof](https://gitlab.com/adarnof/)
+- [Basraah](https://gitlab.com/basraah/)
 
 ### Beta Testers / Bug Fixers
 
@@ -81,6 +89,6 @@ Alliance Auth is maintained and developed by the community and we welcome every
 
 To see what needs to be worked on please review our issue list or chat with our active developers on Discord.
 
-Also, please make sure you have signed the [License Agreement](https://developers.eveonline.com/resource/license-agreement) by logging in at [https://developers.eveonline.com](https://developers.eveonline.com) before submitting any pull requests.
+Also, please make sure you have signed the [License Agreement](https://developers.eveonline.com/license-agreement) by logging in at [https://developers.eveonline.com](https://developers.eveonline.com) before submitting any pull requests.
 
 In addition to the core AA system we also very much welcome contributions to our growing list of 3rd party services and plugin apps. Please see [AA Community Creations](https://gitlab.com/allianceauth/community-creations) for details.

allianceauth/__init__.py

@@ -1,8 +1,12 @@
+"""An auth system for EVE Online to help in-game organizations
+manage online service access.
+"""
+
 # This will make sure the app is always imported when
 # Django starts so that shared_task will use this app.
 
-__version__ = '2.13.0'
+__version__ = '5.0.0a3'
 __title__ = 'Alliance Auth'
+__title_useragent__ = 'AllianceAuth'
 __url__ = 'https://gitlab.com/allianceauth/allianceauth'
 NAME = f'{__title__} v{__version__}'
-default_app_config = 'allianceauth.apps.AllianceAuthConfig'

allianceauth/admin_status/admin.py

@@ -0,0 +1,19 @@
+"""Admin site for admin status applicaton"""
+from django.contrib import admin
+
+from allianceauth.admin_status.models import ApplicationAnnouncement
+
+
+@admin.register(ApplicationAnnouncement)
+class ApplicationAnnouncementAdmin(admin.ModelAdmin):
+    list_display = ["application_name", "announcement_number", "announcement_text", "hide_announcement"]
+    list_filter = ["hide_announcement"]
+    ordering = ["application_name", "announcement_number"]
+    readonly_fields = ["application_name", "announcement_number", "announcement_text", "announcement_url"]
+    fields = ["application_name", "announcement_number", "announcement_text", "announcement_url", "hide_announcement"]
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return False

allianceauth/admin_status/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class AdminStatusApplication(AppConfig):
+    name = 'allianceauth.admin_status'
+    label = 'admin_status'

allianceauth/admin_status/hooks.py

@@ -0,0 +1,207 @@
+import hashlib
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from urllib.parse import quote_plus
+
+import requests
+
+from django.core.cache import cache
+
+from allianceauth.hooks import get_hooks, register
+
+logger = logging.getLogger(__name__)
+
+# timeout for all requests
+REQUESTS_TIMEOUT = 5    # 5 seconds
+# max pages to be fetched from gitlab
+MAX_PAGES = 50
+# Cache time
+NOTIFICATION_CACHE_TIME = 300  # 5 minutes
+
+
+@dataclass
+class Announcement:
+    """
+    Dataclass storing all data for an announcement to be sent arround
+    """
+    application_name: str
+    announcement_url: str
+    announcement_number: int
+    announcement_text: str
+
+    @classmethod
+    def build_from_gitlab_issue_dict(cls, application_name: str, gitlab_issue: dict) -> "Announcement":
+        """Builds the announcement from the JSON dict of a GitLab issue"""
+        return Announcement(application_name, gitlab_issue["web_url"], gitlab_issue["iid"], gitlab_issue["title"])
+
+    @classmethod
+    def build_from_github_issue_dict(cls, application_name: str, github_issue: dict) -> "Announcement":
+        """Builds the announcement from the JSON dict of a GitHub issue"""
+        return Announcement(application_name, github_issue["html_url"], github_issue["number"], github_issue["title"])
+
+    def get_hash(self):
+        """Get a hash of the Announcement for comparison"""
+        name = f"{self.application_name}.{self.announcement_number}"
+        hash_value = hashlib.sha256(name.encode("utf-8")).hexdigest()
+        return hash_value
+
+
+@dataclass
+class AppAnnouncementHook:
+    """
+    A hook for an application to send GitHub/GitLab issues as announcements on the dashboard
+
+    Args:
+        - app_name: The name of your application
+        - repository_namespace: The namespace of the remote repository of your application source code.
+            It should look like `<username>/<application_name>`.
+        - repository_kind: Enumeration to determine if your repository is a GitHub or GitLab repository.
+        - label: The label applied to issues that should be seen as announcements, case-sensitive.
+            Default value: `announcement`
+    """
+    class Service(Enum):
+        """Simple enumeration to determine which api should be called to access issues"""
+        GITLAB = "gitlab"
+        GITHUB = "github"
+
+    app_name: str
+    repository_namespace: str
+    repository_kind: Service
+    label: str = "announcement"
+
+
+    def get_announcement_list(self) -> list[Announcement]:
+        """
+        Checks the application repository to find issues with the `Announcement` tag and return their title and link to
+        be displayed.
+        """
+        logger.debug("Getting announcement list for the app %s", self.app_name)
+        match self.repository_kind:
+            case AppAnnouncementHook.Service.GITHUB:
+                announcement_list = self._get_github_announcement_list()
+            case AppAnnouncementHook.Service.GITLAB:
+                announcement_list = self._get_gitlab_announcement_list()
+            case _:
+                announcement_list = []
+
+        logger.debug("Announcements for app %s: %s", self.app_name, announcement_list)
+        return announcement_list
+
+    def _get_github_announcement_list(self) -> list[Announcement]:
+        """
+        Return the issue list for a GitHub repository
+        Will filter if the `pull_request` attribute is present
+        """
+        raw_list = _fetch_list_from_github(
+            f"https://api.github.com/repos/{self.repository_namespace}/issues"
+            f"?labels={self.label}"
+        )
+        return [Announcement.build_from_github_issue_dict(self.app_name, github_issue) for github_issue in raw_list]
+
+    def _get_gitlab_announcement_list(self) -> list[Announcement]:
+        """Return the issues list for a GitLab repository"""
+        raw_list = _fetch_list_from_gitlab(
+            f"https://gitlab.com/api/v4/projects/{quote_plus(self.repository_namespace)}/issues"
+            f"?labels={self.label}&state=opened")
+        return [Announcement.build_from_gitlab_issue_dict(self.app_name, gitlab_issue) for gitlab_issue in raw_list]
+
+@register("app_announcement_hook")
+def alliance_auth_announcements_hook():
+    return AppAnnouncementHook("AllianceAuth", "allianceauth/allianceauth", AppAnnouncementHook.Service.GITLAB)
+
+def get_all_applications_announcements() -> list[Announcement]:
+    """
+    Retrieve all known application announcements and returns them
+    """
+    application_notifications = []
+
+    hooks = [fn() for fn in get_hooks("app_announcement_hook")]
+    for hook in hooks:
+        logger.debug(hook)
+        try:
+            application_notifications.extend(cache.get_or_set(
+                f"{hook.app_name}_notification_issues",
+                hook.get_announcement_list,
+                NOTIFICATION_CACHE_TIME,
+            ))
+        except requests.HTTPError:
+            logger.warning("Error when getting %s notifications", hook, exc_info=True)
+
+    logger.debug(application_notifications)
+    if application_notifications:
+        application_notifications = application_notifications[:10]
+
+    return application_notifications
+
+
+def _fetch_list_from_gitlab(url: str, max_pages: int = MAX_PAGES) -> list:
+    """returns a list from the GitLab API. Supports paging"""
+    result = []
+
+    for page in range(1, max_pages + 1):
+        try:
+            request = requests.get(
+                url, params={'page': page}, timeout=REQUESTS_TIMEOUT
+            )
+            request.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            error_str = str(e)
+
+            logger.warning(
+                f'Unable to fetch from GitLab API. Error: {error_str}',
+                exc_info=True,
+            )
+
+            return result
+
+        result += request.json()
+
+        if 'x-total-pages' in request.headers:
+            try:
+                total_pages = int(request.headers['x-total-pages'])
+            except ValueError:
+                total_pages = None
+        else:
+            total_pages = None
+
+        if not total_pages or page >= total_pages:
+            break
+
+    return result
+
+def _fetch_list_from_github(url: str, max_pages: int = MAX_PAGES) -> list:
+    """returns a list from the GitHub API. Supports paging"""
+
+    result = []
+    for page in range(1, max_pages+1):
+        try:
+            request = requests.get(
+                url,
+                params={'page': page},
+                headers={
+                    "Accept": "application/vnd.github+json",
+                    "X-GitHub-Api-Version": "2022-11-28"
+                },
+                timeout=REQUESTS_TIMEOUT,
+            )
+            request.raise_for_status()
+        except requests.exceptions.RequestException as e:
+            error_str = str(e)
+
+            logger.warning(
+                f'Unable to fetch from GitHub API. Error: {error_str}',
+                exc_info=True,
+            )
+
+            return result
+
+        result += request.json()
+        logger.debug(request.json())
+
+        # https://docs.github.com/en/rest/using-the-rest-api/using-pagination-in-the-rest-api?apiVersion=2022-11-28
+        # See Example creating a pagination method
+        if not ('link' in request.headers and 'rel=\"next\"' in request.headers['link']):
+            break
+
+    return result

allianceauth/admin_status/managers.py

@@ -0,0 +1,57 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+from allianceauth.admin_status.hooks import (
+    Announcement,
+    get_all_applications_announcements,
+)
+from allianceauth.services.hooks import get_extension_logger
+
+if TYPE_CHECKING:
+    from .models import ApplicationAnnouncement
+
+logger = get_extension_logger(__name__)
+
+class ApplicationAnnouncementManager(models.Manager):
+
+    def sync_and_return(self):
+        """
+        Checks all hooks if new notifications need to be created.
+        Return all notification objects after
+        """
+        logger.info("Syncing announcements")
+        current_announcements = get_all_applications_announcements()
+        self._delete_obsolete_announcements(current_announcements)
+        self._store_new_announcements(current_announcements)
+
+        return self.all()
+
+    def _delete_obsolete_announcements(self, current_announcements: list[Announcement]):
+        """Deletes all announcements stored in the database that aren't retrieved anymore"""
+        hashes = [announcement.get_hash() for announcement in current_announcements]
+        self.exclude(announcement_hash__in=hashes).delete()
+
+    def _store_new_announcements(self, current_announcements: list[Announcement]):
+        """Stores a new database object for new application announcements"""
+
+        for current_announcement in current_announcements:
+            try:
+                announcement = self.get(announcement_hash=current_announcement.get_hash())
+            except self.model.DoesNotExist:
+                self.create_from_announcement(current_announcement)
+            else:
+                # if exists update the text only
+                if announcement.announcement_text != current_announcement.announcement_text:
+                    announcement.announcement_text = current_announcement.announcement_text
+                    announcement.save()
+
+    def create_from_announcement(self, announcement: Announcement) -> "ApplicationAnnouncement":
+        """Creates from the Announcement dataclass"""
+        return self.create(
+            application_name=announcement.application_name,
+            announcement_number=announcement.announcement_number,
+            announcement_text=announcement.announcement_text,
+            announcement_url=announcement.announcement_url,
+            announcement_hash=announcement.get_hash(),
+        )

allianceauth/admin_status/migrations/0001_initial.py

@@ -0,0 +1,33 @@
+# Generated by Django 5.1.9 on 2025-05-18 15:43
+
+import django.db.models.manager
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ApplicationAnnouncement',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('application_name', models.CharField(help_text='Name of the application that issued the announcement', max_length=50)),
+                ('announcement_number', models.IntegerField(help_text='Issue number on the notification source')),
+                ('announcement_text', models.TextField(help_text='Issue title text displayed on the dashboard', max_length=300)),
+                ('announcement_url', models.TextField(max_length=200)),
+                ('announcement_hash', models.CharField(default=None, editable=False, help_text='hash of an announcement. Must be nullable for unique comparison.', max_length=64, null=True, unique=True)),
+                ('hide_announcement', models.BooleanField(default=False, help_text='Set to true if the announcement should not be displayed on the dashboard')),
+            ],
+            options={
+                'constraints': [models.UniqueConstraint(fields=('application_name', 'announcement_number'), name='functional_pk_applicationissuenumber')],
+            },
+            managers=[
+                ('object', django.db.models.manager.Manager()),
+            ],
+        ),
+    ]

allianceauth/admin_status/models.py

@@ -0,0 +1,45 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from allianceauth.admin_status.managers import ApplicationAnnouncementManager
+
+
+class ApplicationAnnouncement(models.Model):
+    """
+    Announcement originating from an application
+    """
+    object = ApplicationAnnouncementManager()
+
+    application_name = models.CharField(max_length=50, help_text=_("Name of the application that issued the announcement"))
+    announcement_number = models.IntegerField(help_text=_("Issue number on the notification source"))
+    announcement_text = models.TextField(max_length=300, help_text=_("Issue title text displayed on the dashboard"))
+    announcement_url = models.TextField(max_length=200)
+
+    announcement_hash = models.CharField(
+        max_length=64,
+        default=None,
+        unique=True,
+        editable=False,
+        help_text="hash of an announcement."
+    )
+
+    hide_announcement = models.BooleanField(
+        default=False,
+        help_text=_("Set to true if the announcement should not be displayed on the dashboard")
+    )
+
+    class Meta:
+        # Should be updated to a composite key when the switch to Django 5.2 is made
+        # https://docs.djangoproject.com/en/5.2/topics/composite-primary-key/
+        constraints = [
+            models.UniqueConstraint(
+                fields=["application_name", "announcement_number"], name="functional_pk_applicationissuenumber"
+            )
+        ]
+
+    def __str__(self):
+        return f"{self.application_name} announcement #{self.announcement_number}"
+
+    def is_hidden(self) -> bool:
+        """Function in case rules are made in the future to force hide/force show some announcements"""
+        return self.hide_announcement

allianceauth/admin_status/templates/admin-status/celery_bar_partial.html

@@ -2,11 +2,13 @@
 {% load admin_status %}
 
 <div
-    class="progress-bar progress-bar-{{ level }} task-status-progress-bar"
+    id="celery-progress-bar-{{ label }}"
+    class="progress-bar text-bg-{{ level }} task-status-progress-bar"
     role="progressbar"
     aria-valuenow="{% decimal_widthratio tasks_count tasks_total 100 %}"
     aria-valuemin="0"
     aria-valuemax="100"
-    style="width: {% decimal_widthratio tasks_count tasks_total 100 %}%;">
-    <p style="margin-top:5px;">{% widthratio tasks_count tasks_total 100 %}%</p>
+    style="width: {% decimal_widthratio tasks_count tasks_total 100 %}%;"
+>
+    <span id="celery-progress-bar-{{ label }}-progress">{% widthratio tasks_count tasks_total 100 %}%</span>
 </div>

allianceauth/admin_status/templates/admin-status/esi_check.html

@@ -0,0 +1,32 @@
+{% load i18n %}
+
+<div id="esi-alert" class="col-12 collapse">
+    <div class="alert alert-warning">
+        <p class="text-center ">{% translate 'Your Server received an ESI error response code of ' %}<b id="esi-code">?</b></p>
+        <hr>
+        <pre id="esi-data" class="text-center text-wrap"></pre>
+    </div>
+
+    <script>
+        $(document).ready(() => {
+            const elements = {
+                card: document.getElementById('esi-alert'),
+                message: document.getElementById('esi-data'),
+                code: document.getElementById('esi-code')
+            };
+
+            fetchGet({url: '{% url "authentication:esi_check" %}'})
+                .then(({status, data}) => {
+                    console.log('ESI Check:', JSON.stringify({status, data}, null, 2));
+
+                    if (status !== 200) {
+                        elements.code.textContent = status;
+                        elements.message.textContent = data.error;
+
+                        new bootstrap.Collapse(elements.card, {toggle: true});
+                    }
+                })
+                .catch((error) => console.error('Error fetching ESI check:', error));
+        });
+    </script>
+</div>

allianceauth/admin_status/templates/admin-status/overview.html

@@ -0,0 +1,198 @@
+{% load i18n %}
+{% load humanize %}
+
+{% get_current_language as LANGUAGE_CODE %}
+
+{% comment %}
+Some translations used in the HTML and JavaScript code below.
+We define them here so that they can be used in the JavaScript code as well with
+the escapejs filter without having to redefine them later.
+{% endcomment %}
+{% translate "second" as l10nSecondSingular %}
+{% translate "seconds" as l10nSecondPlural %}
+{% translate "minute" as l10nMinuteSingular %}
+{% translate "minutes" as l10nMinutePlural %}
+{% translate "hour" as l10nHourSingular %}
+{% translate "hours" as l10nHourPlural %}
+{% translate "N/A" as l10nNA %}
+{% translate "ERROR" as l10nError %}
+{% translate "running" as l10nRunning %}
+{% translate "queued" as l10nQueued %}
+{% translate "succeeded" as l10nSucceeded %}
+{% translate "retried" as l10nRetried %}
+{% translate "failed" as l10nFailed %}
+
+{% if debug %}
+    <div id="aa-dashboard-panel-debug" class="col-12 mb-3">
+        <div class="card text-bg-warning">
+            <div class="card-body">
+                {% translate "Debug mode" as widget_title %}
+                {% include "framework/dashboard/widget-title.html" with title=widget_title %}
+
+                <div>
+                    <p class="text-center">
+                        {% translate "Debug mode is currently turned on!<br>Make sure to turn it off as soon as you are finished testing." %}
+                    </p>
+                </div>
+            </div>
+        </div>
+    </div>
+{% endif %}
+
+{% if notifications %}
+    <div id="aa-dashboard-panel-admin-application-notifications" class="col-12 mb-3">
+        <div class="card">
+            <div class="card-body">
+                {% translate "Announcements" as widget_title %}
+                {% include "framework/dashboard/widget-title.html" with title=widget_title %}
+
+                <div>
+                    <ul class="list-group">
+                        {% for notif in notifications %}
+                            <li class="list-group-item">
+                                <span class="badge text-bg-success me-2">{% translate "Open" %}</span>
+                                <a href="{{ notif.web_url }}" target="_blank">#{{ notif.iid }} {{ notif.title }}</a>
+                            </li>
+                        {% empty %}
+                            <div class="alert alert-primary" role="alert">
+                                {% translate "No notifications at this time" %}
+                            </div>
+                        {% endfor %}
+                    </ul>
+
+                    <div class="text-end pt-3">
+                        <a href="https://gitlab.com/allianceauth/allianceauth/issues" target="_blank" class="me-1 text-decoration-none">
+                            <span class="badge text-bg-danger">
+                                <i class="fab fa-gitlab" aria-hidden="true"></i>
+                                {% translate 'Powered by GitLab' %}
+                            </span>
+                        </a>
+                        <a href="https://discord.com/invite/fjnHAmk" target="_blank" class="text-decoration-none">
+                            <span class="badge text-bg-info">
+                                <i class="fab fa-discord" aria-hidden="true"></i>
+                                {% translate 'Support Discord' %}
+                            </span>
+                        </a>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+{% endif %}
+
+<div class="col-12 mb-3">
+    <div class="card">
+        <div class="card-body row">
+            <div id="aa-dashboard-panel-software-version" class="col-xl-6 col-lg-12 col-md-12 col-sm-12">
+                {% translate "Software Version" as widget_title %}
+                {% include "framework/dashboard/widget-title.html" with title=widget_title %}
+
+                <div>
+                    <ul class="list-group list-group-horizontal w-100" role="group" aria-label="{% translate 'Software Version' %}">
+                        <li class="list-group-item w-100">
+                            <div class="btn h-100 w-100 cursor-default">
+                                <h5 class="list-group-item-heading">{% translate "Current" %}</h5>
+                                <p class="list-group-item-text">{{ current_version }}</p>
+                            </div>
+                        </li>
+
+                        <li class="list-group-item text-bg-{% if latest_patch %}success{% elif latest_minor %}warning{% else %}danger{% endif %} w-100">
+                            <a class="btn h-100 w-100" href="https://gitlab.com/allianceauth/allianceauth/-/releases/v{{ latest_patch_version }}">
+                                <h5 class="list-group-item-heading">{% translate "Latest Stable" %}</h5>
+
+                                <p class="list-group-item-text">
+                                    <i class="fab fa-gitlab hidden-xs" aria-hidden="true"></i>
+                                    {{ latest_patch_version }}
+                                    {% if not latest_patch %}<br>{% translate "Update available" %}{% endif %}
+                                </p>
+                            </a>
+                        </li>
+
+                        {% if latest_beta %}
+                            <li class="list-group-item text-bg-info w-100">
+                                <a class="btn h-100 w-100" href="https://gitlab.com/allianceauth/allianceauth/-/releases/v{{ latest_beta_version }}">
+                                    <h5 class="list-group-item-heading">{% translate "Latest Pre-Release" %}</h5>
+
+                                    <p class="list-group-item-text">
+                                        <i class="fab fa-gitlab hidden-xs" aria-hidden="true"></i>
+                                        {{ latest_beta_version }}
+                                        <br>{% translate "Pre-Release available" %}
+                                    </p>
+                                </a>
+                            </li>
+                        {% endif %}
+                    </ul>
+                </div>
+            </div>
+
+            <div id="aa-dashboard-panel-task-queue" class="col-xl-6 col-lg-12 col-md-12 col-sm-12">
+                {% translate "Task Queue" as widget_title %}
+                {% include "framework/dashboard/widget-title.html" with title=widget_title %}
+
+                <div>
+                    <p>
+                        {% blocktranslate with total=tasks_total|intcomma latest=earliest_task|timesince|default:"?" %}
+                            Status of <span id="total-task-count">?</span> processed tasks • last <span id="celery-uptime">?</span>
+                        {% endblocktranslate %}
+                    </p>
+
+                    <div
+                        id="celery-tasks-progress-bar"
+                        class="progress mb-2"
+                        style="height: 21px;"
+                        title="? {{ l10nSucceeded }}, ? {{ l10nRetried }}, ? {{ l10nFailed }}"
+                    >
+                        {% include "allianceauth/admin-status/celery_bar_partial.html" with label="succeeded" level="success" tasks_count=0 %}
+                        {% include "allianceauth/admin-status/celery_bar_partial.html" with label="retried" level="info" tasks_count=0 %}
+                        {% include "allianceauth/admin-status/celery_bar_partial.html" with label="failed" level="danger" tasks_count=0 %}
+                    </div>
+
+                    <p>
+                        <span id="running-task-count">?</span> {{ l10nRunning }} |
+                        <span id="queued-tasks-count">?</span> {{ l10nQueued }} |
+                        <span id="succeeded-tasks-count">?</span> {{ l10nSucceeded }} |
+                        <span id="retried-tasks-count">?</span> {{ l10nRetried }} |
+                        <span id="failed-tasks-count">?</span> {{ l10nFailed }}
+                    </p>
+                </div>
+            </div>
+            <div class="text-end pt-3">
+                <a href="https://gitlab.com/allianceauth/allianceauth/issues" target="_blank" class="me-1 text-decoration-none">
+                            <span class="badge" style="background-color: rgb(230 83 40);">
+                                <i class="fab fa-gitlab" aria-hidden="true"></i>
+                                {% translate 'Powered by GitLab' %}
+                            </span>
+                </a>
+                <a href="https://discord.com/invite/fjnHAmk" target="_blank" class="text-decoration-none">
+                            <span class="badge" style="background-color: rgb(110 133 211);">
+                                <i class="fab fa-discord" aria-hidden="true"></i>
+                                {% translate 'Support Discord' %}
+                            </span>
+                </a>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    const taskQueueSettings = {
+        url: '{% url "authentication:task_counts" %}',
+        l10n: {
+            language: '{{ LANGUAGE_CODE }}',
+            second_singular: '{{ l10nSecondSingular|escapejs }}',
+            second_plural: '{{ l10nSecondPlural|escapejs }}',
+            minute_singular: '{{ l10nMinuteSingular|escapejs }}',
+            minute_plural: '{{ l10nMinutePlural|escapejs }}',
+            hour_singular: '{{ l10nHourSingular|escapejs }}',
+            hour_plural: '{{ l10nHourPlural|escapejs }}',
+            na: '{{ l10nNA|escapejs }}',
+            error: '{{ l10nError|escapejs }}',
+            running: '{{ l10nRunning|escapejs }}',
+            queued: '{{ l10nQueued|escapejs }}',
+            succeeded: '{{ l10nSucceeded|escapejs }}',
+            retried: '{{ l10nRetried|escapejs }}',
+            failed: '{{ l10nFailed|escapejs }}'
+        }
+    };
+</script>
+{% include "bundles/auth-dashboard-task-queue-js.html" %}

allianceauth/admin_status/templatetags/admin_status.py

@@ -1,19 +1,17 @@
 import logging
-from typing import Optional
 
-import amqp.exceptions
 import requests
-from celery.app import app_or_default
-from packaging.version import InvalidVersion
-from packaging.version import Version as Pep440Version
+from packaging.version import InvalidVersion, Version as Pep440Version
 
 from django import template
 from django.conf import settings
 from django.core.cache import cache
 
 from allianceauth import __version__
-
-from ..authentication.task_statistics.counters import dashboard_results
+from allianceauth.admin_status.models import ApplicationAnnouncement
+from allianceauth.authentication.task_statistics.counters import (
+    dashboard_results,
+)
 
 register = template.Library()
 
@@ -28,10 +26,6 @@ MAX_PAGES = 50
 GITLAB_AUTH_REPOSITORY_TAGS_URL = (
     'https://gitlab.com/api/v4/projects/allianceauth%2Fallianceauth/repository/tags'
 )
-GITLAB_AUTH_ANNOUNCEMENT_ISSUES_URL = (
-    'https://gitlab.com/api/v4/projects/allianceauth%2Fallianceauth/issues'
-    '?labels=announcement&state=opened'
-)
 
 logger = logging.getLogger(__name__)
 
@@ -41,25 +35,24 @@ def decimal_widthratio(this_value, max_value, max_width) -> str:
     if max_value == 0:
         return str(0)
 
-    return str(round(this_value/max_value * max_width, 2))
+    return str(round(this_value / max_value * max_width, 2))
 
 
-@register.inclusion_tag('allianceauth/admin-status/overview.html')
+@register.inclusion_tag('admin-status/overview.html')
 def status_overview() -> dict:
     response = {
-        "notifications": list(),
+        "notifications": [],
         "current_version": __version__,
-        "task_queue_length": None,
         "tasks_succeeded": 0,
         "tasks_retried": 0,
         "tasks_failed": 0,
         "tasks_total": 0,
         "tasks_hours": 0,
-        "earliest_task": None
+        "earliest_task": None,
+        "debug": settings.DEBUG if settings.DISPLAY_DEBUG else False,
     }
     response.update(_current_notifications())
     response.update(_current_version_summary())
-    response.update({'task_queue_length': _fetch_celery_queue_length()})
     response.update(_celery_stats())
     return response
 
@@ -73,54 +66,20 @@ def _celery_stats() -> dict:
         "tasks_failed": results.failed,
         "tasks_total": results.total,
         "tasks_hours": results.hours,
-        "earliest_task": results.earliest_task
+        "earliest_task": results.earliest_task,
     }
 
 
-def _fetch_celery_queue_length() -> Optional[int]:
-    try:
-        app = app_or_default(None)
-        with app.connection_or_acquire() as conn:
-            result = conn.default_channel.queue_declare(
-                queue=getattr(settings, 'CELERY_DEFAULT_QUEUE', 'celery'),
-                passive=True
-            )
-            return result.message_count
-    except amqp.exceptions.ChannelError:
-        # Queue doesn't exist, probably empty
-        return 0
-    except Exception:
-        logger.exception("Failed to get celery queue length")
-    return None
-
-
 def _current_notifications() -> dict:
-    """returns the newest 5 announcement issues"""
-    try:
-        notifications = cache.get_or_set(
-            'gitlab_notification_issues',
-            _fetch_notification_issues_from_gitlab,
-            NOTIFICATION_CACHE_TIME
-        )
-    except requests.HTTPError:
-        logger.warning('Error while getting gitlab notifications', exc_info=True)
-        top_notifications = []
-    else:
-        if notifications:
-            top_notifications = notifications[:5]
-        else:
-            top_notifications = []
+    """returns announcements from AllianceAuth and third party applications"""
+
+    application_notifications = ApplicationAnnouncement.object.sync_and_return()
 
     response = {
-        'notifications': top_notifications,
+        'notifications': application_notifications,
     }
     return response
 
-
-def _fetch_notification_issues_from_gitlab() -> list:
-    return _fetch_list_from_gitlab(GITLAB_AUTH_ANNOUNCEMENT_ISSUES_URL, max_pages=10)
-
-
 def _current_version_summary() -> dict:
     """returns the current version info"""
     try:
@@ -166,8 +125,8 @@ def _latests_versions(tags: list) -> tuple:
 
     Non-compliant tags will be ignored
     """
-    versions = list()
-    betas = list()
+    versions = []
+    betas = []
     for tag in tags:
         try:
             version = Pep440Version(tag.get('name'))
@@ -189,7 +148,7 @@ def _latests_versions(tags: list) -> tuple:
 
 def _fetch_list_from_gitlab(url: str, max_pages: int = MAX_PAGES) -> list:
     """returns a list from the GitLab API. Supports paging"""
-    result = list()
+    result = []
 
     for page in range(1, max_pages + 1):
         try:

allianceauth/admin_status/tests/test_hooks.py

@@ -0,0 +1,194 @@
+import requests_mock
+
+from allianceauth.admin_status.hooks import Announcement
+from allianceauth.services.hooks import AppAnnouncementHook
+from allianceauth.utils.testing import NoSocketsTestCase
+
+
+class TestHooks(NoSocketsTestCase):
+
+    @requests_mock.mock()
+    def test_fetch_gitlab(self, requests_mocker):
+        # given
+        announcement_hook = AppAnnouncementHook("test GitLab app", "r0kym/allianceauth-example-plugin",
+                                                AppAnnouncementHook.Service.GITLAB)
+        requests_mocker.get(
+            "https://gitlab.com/api/v4/projects/r0kym%2Fallianceauth-example-plugin/issues?labels=announcement&state=opened",
+            json=[
+                {
+                    "id": 166279127,
+                    "iid": 1,
+                    "project_id": 67653102,
+                    "title": "Test GitLab issue",
+                    "description": "Test issue",
+                    "state": "opened",
+                    "created_at": "2025-04-20T21:26:57.914Z",
+                    "updated_at": "2025-04-21T11:04:30.501Z",
+                    "closed_at": None,
+                    "closed_by": None,
+                    "labels": [
+                        "announcement"
+                    ],
+                    "milestone": None,
+                    "assignees": [],
+                    "author": {
+                        "id": 14491514,
+                        "username": "r0kym",
+                        "public_email": "",
+                        "name": "T'rahk Rokym",
+                        "state": "active",
+                        "locked": False,
+                        "avatar_url": "https://gitlab.com/uploads/-/system/user/avatar/14491514/avatar.png",
+                        "web_url": "https://gitlab.com/r0kym"
+                    },
+                    "type": "ISSUE",
+                    "assignee": None,
+                    "user_notes_count": 0,
+                    "merge_requests_count": 0,
+                    "upvotes": 0,
+                    "downvotes": 0,
+                    "due_date": None,
+                    "confidential": False,
+                    "discussion_locked": None,
+                    "issue_type": "issue",
+                    "web_url": "https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+                    "time_stats": {
+                        "time_estimate": 0,
+                        "total_time_spent": 0,
+                        "human_time_estimate": None,
+                        "human_total_time_spent": None
+                    },
+                    "task_completion_status": {
+                        "count": 0,
+                        "completed_count": 0
+                    },
+                    "blocking_issues_count": 0,
+                    "has_tasks": True,
+                    "task_status": "0 of 0 checklist items completed",
+                    "_links": {
+                        "self": "https://gitlab.com/api/v4/projects/67653102/issues/1",
+                        "notes": "https://gitlab.com/api/v4/projects/67653102/issues/1/notes",
+                        "award_emoji": "https://gitlab.com/api/v4/projects/67653102/issues/1/award_emoji",
+                        "project": "https://gitlab.com/api/v4/projects/67653102",
+                        "closed_as_duplicate_of": None
+                    },
+                    "references": {
+                        "short": "#1",
+                        "relative": "#1",
+                        "full": "r0kym/allianceauth-example-plugin#1"
+                    },
+                    "severity": "UNKNOWN",
+                    "moved_to_id": None,
+                    "imported": False,
+                    "imported_from": "none",
+                    "service_desk_reply_to": None
+                }
+            ]
+        )
+        # when
+        announcements = announcement_hook.get_announcement_list()
+        # then
+        self.assertEqual(len(announcements), 1)
+        self.assertIn(Announcement(
+            application_name="test GitLab app",
+            announcement_url="https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+            announcement_number=1,
+            announcement_text="Test GitLab issue"
+        ), announcements)
+
+    @requests_mock.mock()
+    def test_fetch_github(self, requests_mocker):
+        # given
+        announcement_hook = AppAnnouncementHook("test GitHub app", "r0kym/test", AppAnnouncementHook.Service.GITHUB)
+        requests_mocker.get(
+            "https://api.github.com/repos/r0kym/test/issues?labels=announcement",
+            json=[
+                {
+                    "url": "https://api.github.com/repos/r0kym/test/issues/1",
+                    "repository_url": "https://api.github.com/repos/r0kym/test",
+                    "labels_url": "https://api.github.com/repos/r0kym/test/issues/1/labels{/name}",
+                    "comments_url": "https://api.github.com/repos/r0kym/test/issues/1/comments",
+                    "events_url": "https://api.github.com/repos/r0kym/test/issues/1/events",
+                    "html_url": "https://github.com/r0kym/test/issues/1",
+                    "id": 3007269496,
+                    "node_id": "I_kwDOOc2YvM6zP0p4",
+                    "number": 1,
+                    "title": "GitHub issue",
+                    "user": {
+                        "login": "r0kym",
+                        "id": 56434393,
+                        "node_id": "MDQ6VXNlcjU2NDM0Mzkz",
+                        "avatar_url": "https://avatars.githubusercontent.com/u/56434393?v=4",
+                        "gravatar_id": "",
+                        "url": "https://api.github.com/users/r0kym",
+                        "html_url": "https://github.com/r0kym",
+                        "followers_url": "https://api.github.com/users/r0kym/followers",
+                        "following_url": "https://api.github.com/users/r0kym/following{/other_user}",
+                        "gists_url": "https://api.github.com/users/r0kym/gists{/gist_id}",
+                        "starred_url": "https://api.github.com/users/r0kym/starred{/owner}{/repo}",
+                        "subscriptions_url": "https://api.github.com/users/r0kym/subscriptions",
+                        "organizations_url": "https://api.github.com/users/r0kym/orgs",
+                        "repos_url": "https://api.github.com/users/r0kym/repos",
+                        "events_url": "https://api.github.com/users/r0kym/events{/privacy}",
+                        "received_events_url": "https://api.github.com/users/r0kym/received_events",
+                        "type": "User",
+                        "user_view_type": "public",
+                        "site_admin": False
+                    },
+                    "labels": [
+                        {
+                            "id": 8487814480,
+                            "node_id": "LA_kwDOOc2YvM8AAAAB-enFUA",
+                            "url": "https://api.github.com/repos/r0kym/test/labels/announcement",
+                            "name": "announcement",
+                            "color": "aaaaaa",
+                            "default": False,
+                            "description": None
+                        }
+                    ],
+                    "state": "open",
+                    "locked": False,
+                    "assignee": None,
+                    "assignees": [],
+                    "milestone": None,
+                    "comments": 0,
+                    "created_at": "2025-04-20T22:41:10Z",
+                    "updated_at": "2025-04-21T11:05:08Z",
+                    "closed_at": None,
+                    "author_association": "OWNER",
+                    "active_lock_reason": None,
+                    "sub_issues_summary": {
+                        "total": 0,
+                        "completed": 0,
+                        "percent_completed": 0
+                    },
+                    "body": None,
+                    "closed_by": None,
+                    "reactions": {
+                        "url": "https://api.github.com/repos/r0kym/test/issues/1/reactions",
+                        "total_count": 0,
+                        "+1": 0,
+                        "-1": 0,
+                        "laugh": 0,
+                        "hooray": 0,
+                        "confused": 0,
+                        "heart": 0,
+                        "rocket": 0,
+                        "eyes": 0
+                    },
+                    "timeline_url": "https://api.github.com/repos/r0kym/test/issues/1/timeline",
+                    "performed_via_github_app": None,
+                    "state_reason": None
+                }
+            ]
+        )
+        # when
+        announcements = announcement_hook.get_announcement_list()
+        # then
+        self.assertEqual(len(announcements), 1)
+        self.assertIn(Announcement(
+            application_name="test GitHub app",
+            announcement_url="https://github.com/r0kym/test/issues/1",
+            announcement_number=1,
+            announcement_text="GitHub issue"
+        ), announcements)

allianceauth/admin_status/tests/test_managers.py

@@ -0,0 +1,75 @@
+from unittest.mock import patch
+
+from allianceauth.admin_status.hooks import Announcement
+from allianceauth.admin_status.models import ApplicationAnnouncement
+from allianceauth.utils.testing import NoSocketsTestCase
+
+MODULE_PATH = 'allianceauth.admin_status.managers'
+
+DEFAULT_ANNOUNCEMENTS = [
+    Announcement(
+        application_name="Test GitHub Application",
+        announcement_number=1,
+        announcement_text="GitHub issue",
+        announcement_url="https://github.com/r0kym/test/issues/1",
+    ),
+    Announcement(
+        application_name="Test Gitlab Application",
+        announcement_number=1,
+        announcement_text="GitLab issue",
+        announcement_url="https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+    )
+]
+
+class TestSyncManager(NoSocketsTestCase):
+
+    def setUp(self):
+        ApplicationAnnouncement.object.create(
+            application_name="Test GitHub Application",
+            announcement_number=1,
+            announcement_text="GitHub issue",
+            announcement_url="https://github.com/r0kym/test/issues/1",
+            announcement_hash="9dbedb9c47529bb43cfecb704768a35d085b145930e13cced981623e5f162a85",
+        )
+        ApplicationAnnouncement.object.create(
+            application_name="Test Gitlab Application",
+            announcement_number=1,
+            announcement_text="GitLab issue",
+            announcement_url="https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+            announcement_hash="8955a9c12a1cfa9e1776662bdaf111147b84e35c79f24bfb758e35333a18b1bd",
+        )
+
+    @patch(MODULE_PATH + '.get_all_applications_announcements')
+    def test_announcements_stay_as_is(self, all_announcements_mocker):
+        # given
+        announcement_ids = set(ApplicationAnnouncement.object.values_list("id", flat=True))
+        all_announcements_mocker.return_value = DEFAULT_ANNOUNCEMENTS
+        # when
+        ApplicationAnnouncement.object.sync_and_return()
+        # then
+        self.assertEqual(ApplicationAnnouncement.object.count(), 2)
+        self.assertEqual(set(ApplicationAnnouncement.object.values_list("id", flat=True)), announcement_ids)
+
+    @patch(MODULE_PATH + '.get_all_applications_announcements')
+    def test_announcement_add(self, all_announcements_mocker):
+        # given
+        returned_announcements = DEFAULT_ANNOUNCEMENTS + [Announcement(application_name="Test Application", announcement_number=1, announcement_text="New test announcement", announcement_url="https://example.com")]
+        all_announcements_mocker.return_value = returned_announcements
+        # when
+        ApplicationAnnouncement.object.sync_and_return()
+        # then
+        self.assertEqual(ApplicationAnnouncement.object.count(), 3)
+        self.assertTrue(ApplicationAnnouncement.object.filter(application_name="Test Application", announcement_number=1, announcement_text="New test announcement", announcement_url="https://example.com"))
+
+    @patch(MODULE_PATH + '.get_all_applications_announcements')
+    def test_announcement_remove(self, all_announcements_mocker):
+        # given
+        all_announcements_mocker.return_value = DEFAULT_ANNOUNCEMENTS
+        ApplicationAnnouncement.object.sync_and_return()
+        self.assertEqual(ApplicationAnnouncement.object.count(), 2)
+        all_announcements_mocker.return_value = DEFAULT_ANNOUNCEMENTS[:1]
+        # when
+        ApplicationAnnouncement.object.sync_and_return()
+        # then
+        self.assertEqual(ApplicationAnnouncement.object.count(), 1)
+        self.assertTrue(ApplicationAnnouncement.object.filter(application_name="Test GitHub Application").exists())

allianceauth/admin_status/tests/test_templatetags.py

@@ -8,23 +8,61 @@ from packaging.version import Version as Pep440Version
 from django.core.cache import cache
 from django.test import TestCase
 
-from allianceauth.templatetags.admin_status import (
-    status_overview,
-    _fetch_list_from_gitlab,
+from allianceauth.admin_status.models import ApplicationAnnouncement
+from allianceauth.admin_status.templatetags.admin_status import (
     _current_notifications,
     _current_version_summary,
-    _fetch_notification_issues_from_gitlab,
-    _latests_versions
+    _fetch_list_from_gitlab,
+    _latests_versions,
+    status_overview,
 )
 
-MODULE_PATH = 'allianceauth.templatetags'
+MODULE_PATH = 'allianceauth.admin_status.templatetags'
 
 
 def create_tags_list(tag_names: list):
     return [{'name': str(tag_name)} for tag_name in tag_names]
 
+def get_app_announcement_as_dict(app_announcement: ApplicationAnnouncement) -> dict:
+    """Transforms an app announcement object in a dict easy to compare"""
+    return {
+        "application_name": app_announcement.application_name,
+        "announcement_number": app_announcement.announcement_number,
+        "announcement_text": app_announcement.announcement_text,
+        "announcement_url": app_announcement.announcement_url,
+    }
+
 
 GITHUB_TAGS = create_tags_list(['v2.4.6a1', 'v2.4.5', 'v2.4.0', 'v2.0.0', 'v1.1.1'])
+STORED_NOTIFICATIONS = [
+    ApplicationAnnouncement(
+        application_name="Test GitHub Application",
+        announcement_number=1,
+        announcement_text="GitHub issue",
+        announcement_url="https://github.com/r0kym/test/issues/1",
+        announcement_hash="hash1",
+    ),
+    ApplicationAnnouncement(
+        application_name="Test Gitlab Application",
+        announcement_number=1,
+        announcement_text="GitLab issue",
+        announcement_url="https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+        announcement_hash="hash2",
+    ),
+]
+ANNOUNCEMENT_DICT = [
+    {
+        "application_name": "Test GitHub Application",
+        "announcement_number": 1,
+        "announcement_text": "GitHub issue",
+        "announcement_url": "https://github.com/r0kym/test/issues/1",
+    }, {
+        "application_name": "Test Gitlab Application",
+        "announcement_number": 1,
+        "announcement_text": "GitLab issue",
+        "announcement_url": "https://gitlab.com/r0kym/allianceauth-example-plugin/-/issues/1",
+    }
+]
 GITHUB_NOTIFICATION_ISSUES = [
     {
         'id': 1,
@@ -52,18 +90,18 @@ GITHUB_NOTIFICATION_ISSUES = [
     },
 ]
 TEST_VERSION = '2.6.5'
+GITLAB_AUTH_ANNOUNCEMENT_ISSUES_URL = (
+    'https://gitlab.com/api/v4/projects/allianceauth%2Fallianceauth/issues'
+    '?labels=announcement&state=opened'
+)
 
 
 class TestStatusOverviewTag(TestCase):
     @patch(MODULE_PATH + '.admin_status.__version__', TEST_VERSION)
-    @patch(MODULE_PATH + '.admin_status._fetch_celery_queue_length')
     @patch(MODULE_PATH + '.admin_status._current_version_summary')
     @patch(MODULE_PATH + '.admin_status._current_notifications')
     def test_status_overview(
-        self,
-        mock_current_notifications,
-        mock_current_version_info,
-        mock_fetch_celery_queue_length
+        self, mock_current_notifications, mock_current_version_info
     ):
         # given
         notifications = {
@@ -82,7 +120,6 @@ class TestStatusOverviewTag(TestCase):
             'latest_beta_version': '2.4.4a1',
         }
         mock_current_version_info.return_value = version_info
-        mock_fetch_celery_queue_length.return_value = 3
         # when
         result = status_overview()
         # then
@@ -96,7 +133,6 @@ class TestStatusOverviewTag(TestCase):
         self.assertEqual(result["latest_minor_version"], '2.4.0')
         self.assertEqual(result["latest_patch_version"], '2.4.5')
         self.assertEqual(result["latest_beta_version"], '2.4.4a1')
-        self.assertEqual(result["task_queue_length"], 3)
 
 
 class TestNotifications(TestCase):
@@ -113,18 +149,19 @@ class TestNotifications(TestCase):
         )
         requests_mocker.get(url, json=GITHUB_NOTIFICATION_ISSUES)
         # when
-        result = _fetch_notification_issues_from_gitlab()
+        result = _fetch_list_from_gitlab(GITLAB_AUTH_ANNOUNCEMENT_ISSUES_URL, 10)
         # then
         self.assertEqual(result, GITHUB_NOTIFICATION_ISSUES)
 
-    @patch(MODULE_PATH + '.admin_status.cache')
-    def test_current_notifications_normal(self, mock_cache):
+    @patch(MODULE_PATH + '.admin_status.ApplicationAnnouncement')
+    def test_current_notifications_normal(self, mock_application_announcement):
         # given
-        mock_cache.get_or_set.return_value = GITHUB_NOTIFICATION_ISSUES
+        mock_application_announcement.object.sync_and_return.return_value = STORED_NOTIFICATIONS
         # when
         result = _current_notifications()
         # then
-        self.assertEqual(result['notifications'], GITHUB_NOTIFICATION_ISSUES[:5])
+        for notification in result["notifications"]:
+            self.assertIn(get_app_announcement_as_dict(notification), ANNOUNCEMENT_DICT)
 
     @requests_mock.mock()
     def test_current_notifications_failed(self, requests_mocker):
@@ -137,16 +174,7 @@ class TestNotifications(TestCase):
         # when
         result = _current_notifications()
         # then
-        self.assertEqual(result['notifications'], list())
-
-    @patch(MODULE_PATH + '.admin_status.cache')
-    def test_current_notifications_is_none(self, mock_cache):
-        # given
-        mock_cache.get_or_set.return_value = None
-        # when
-        result = _current_notifications()
-        # then
-        self.assertEqual(result['notifications'], list())
+        self.assertEqual(list(result['notifications']), [])
 
 
 class TestCeleryQueueLength(TestCase):

allianceauth/analytics/__init__.py

@@ -1 +0,0 @@
-default_app_config = 'allianceauth.analytics.apps.AnalyticsConfig'

allianceauth/analytics/admin.py

@@ -1,21 +1,17 @@
+from solo.admin import SingletonModelAdmin
+
 from django.contrib import admin
 
-from .models import AnalyticsIdentifier, AnalyticsPath, AnalyticsTokens
+from .models import AnalyticsIdentifier, AnalyticsTokens
 
 
 @admin.register(AnalyticsIdentifier)
-class AnalyticsIdentifierAdmin(admin.ModelAdmin):
+class AnalyticsIdentifierAdmin(SingletonModelAdmin):
     search_fields = ['identifier', ]
-    list_display = ('identifier',)
+    list_display = ['identifier', ]
 
 
 @admin.register(AnalyticsTokens)
 class AnalyticsTokensAdmin(admin.ModelAdmin):
     search_fields = ['name', ]
-    list_display = ('name', 'type',)
-
-
-@admin.register(AnalyticsPath)
-class AnalyticsPathAdmin(admin.ModelAdmin):
-    search_fields = ['ignore_path', ]
-    list_display = ('ignore_path',)
+    list_display = ['name', 'type', ]

allianceauth/analytics/apps.py

@@ -1,9 +1,8 @@
 from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
 
 
 class AnalyticsConfig(AppConfig):
     name = 'allianceauth.analytics'
     label = 'analytics'
-
-    def ready(self):
-        import allianceauth.analytics.signals
+    verbose_name = _('Analytics')

allianceauth/analytics/fixtures/disable_analytics.json

@@ -3,11 +3,10 @@
     "model": "analytics.AnalyticsTokens",
     "pk": 1,
     "fields": {
-        "name": "AA Team Public Google Analytics (Universal)",
+        "name": "AA Team Public Google Analytics (V4)",
         "type": "GA-V4",
-        "token": "UA-186249766-2",
-        "send_page_views": "False",
-        "send_celery_tasks": "False",
+        "token": "G-6LYSMYK8DE",
+        "secret": "KLlpjLZ-SRGozS5f5wb_kw",
         "send_stats": "False"
         }
     },

allianceauth/analytics/middleware.py

@@ -1,52 +0,0 @@
-from bs4 import BeautifulSoup
-
-from django.conf import settings
-from django.utils.deprecation import MiddlewareMixin
-from .models import AnalyticsTokens, AnalyticsIdentifier
-from .tasks import send_ga_tracking_web_view
-
-import re
-
-
-class AnalyticsMiddleware(MiddlewareMixin):
-    def process_response(self, request, response):
-        """Django Middleware: Process Page Views and creates Analytics Celery Tasks"""
-        if getattr(settings, "ANALYTICS_DISABLED", False):
-            return response
-        analyticstokens = AnalyticsTokens.objects.all()
-        client_id = AnalyticsIdentifier.objects.get(id=1).identifier.hex
-        try:
-            title = BeautifulSoup(
-                response.content, "html.parser").html.head.title.text
-        except AttributeError:
-            title = ''
-        for token in analyticstokens:
-            # Check if Page View Sending is Disabled
-            if token.send_page_views is False:
-                continue
-            # Check Exclusions
-            ignore = False
-            for ignore_path in token.ignore_paths.values():
-                ignore_path_regex = re.compile(ignore_path["ignore_path"])
-                if re.search(ignore_path_regex, request.path) is not None:
-                    ignore = True
-
-            if ignore is True:
-                continue
-
-            tracking_id = token.token
-            locale = request.LANGUAGE_CODE
-            path = request.path
-            try:
-                useragent = request.headers["User-Agent"]
-            except KeyError:
-                useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
-
-            send_ga_tracking_web_view.s(tracking_id=tracking_id,
-                                        client_id=client_id,
-                                        page=path,
-                                        title=title,
-                                        locale=locale,
-                                        useragent=useragent).\
-                apply_async(priority=9)
-        return response

allianceauth/analytics/migrations/0001_initial.py

@@ -1,8 +1,9 @@
 # Generated by Django 3.1.4 on 2020-12-30 13:11
 
-from django.db import migrations, models
 import uuid
 
+from django.db import migrations, models
+
 
 class Migration(migrations.Migration):
 

allianceauth/analytics/migrations/0002_add_AA_Team_Token.py

@@ -21,7 +21,7 @@ def remove_aa_team_token(apps, schema_editor):
     # Have to define some code to remove this identifier
     # In case of migration rollback?
     Tokens = apps.get_model('analytics', 'AnalyticsTokens')
-    token = Tokens.objects.filter(token="UA-186249766-2").delete()
+    Tokens.objects.filter(token="UA-186249766-2").delete()
 
 
 class Migration(migrations.Migration):

allianceauth/analytics/migrations/0003_Generate_Identifier.py

@@ -1,6 +1,5 @@
 # Generated by Django 3.1.4 on 2020-12-30 08:53
 
-from uuid import uuid4
 from django.db import migrations
 
 

allianceauth/analytics/migrations/0007_analyticstokens_secret.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.0.6 on 2022-08-30 05:47
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('analytics', '0006_more_ignore_paths'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='analyticstokens',
+            name='secret',
+            field=models.CharField(blank=True, max_length=254),
+        ),
+    ]

allianceauth/analytics/migrations/0008_add_AA_GA-4_Team_Token .py

@@ -0,0 +1,64 @@
+# Generated by Django 3.1.4 on 2020-12-30 08:53
+
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import migrations
+
+
+def add_aa_team_token(apps, schema_editor):
+    # We can't import the Person model directly as it may be a newer
+    # version than this migration expects. We use the historical version.
+    Tokens = apps.get_model('analytics', 'AnalyticsTokens')
+    AnalyticsPath = apps.get_model('analytics', 'AnalyticsPath')
+    token = Tokens()
+    try:
+        ua_token = Tokens.objects.get(token="UA-186249766-2")
+        original_send_page_views = ua_token.send_page_views
+        original_send_celery_tasks = ua_token.send_celery_tasks
+        original_send_stats = ua_token.send_stats
+    except ObjectDoesNotExist:
+        original_send_page_views = True
+        original_send_celery_tasks = True
+        original_send_stats = True
+
+    try:
+        user_notifications_count = AnalyticsPath.objects.get(ignore_path=r"^\/user_notifications_count\/.*",)
+    except ObjectDoesNotExist:
+        user_notifications_count = AnalyticsPath.objects.create(ignore_path=r"^\/user_notifications_count\/.*")
+
+    try:
+        admin = AnalyticsPath.objects.get(ignore_path=r"^\/admin\/.*")
+    except ObjectDoesNotExist:
+        admin = AnalyticsPath.objects.create(ignore_path=r"^\/admin\/.*")
+
+    try:
+        account_activate = AnalyticsPath.objects.get(ignore_path=r"^\/account\/activate\/.*")
+    except ObjectDoesNotExist:
+        account_activate = AnalyticsPath.objects.create(ignore_path=r"^\/account\/activate\/.*")
+
+    token.type = 'GA-V4'
+    token.token = 'G-6LYSMYK8DE'
+    token.secret = 'KLlpjLZ-SRGozS5f5wb_kw'
+    token.send_page_views = original_send_page_views
+    token.send_celery_tasks = original_send_celery_tasks
+    token.send_stats = original_send_stats
+    token.name = 'AA Team Public Google Analytics (V4)'
+    token.save()
+    token.ignore_paths.add(admin, user_notifications_count, account_activate)
+    token.save()
+
+
+def remove_aa_team_token(apps, schema_editor):
+    # Have to define some code to remove this identifier
+    # In case of migration rollback?
+    Tokens = apps.get_model('analytics', 'AnalyticsTokens')
+    Tokens.objects.filter(token="G-6LYSMYK8DE").delete()
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('analytics', '0007_analyticstokens_secret'),
+    ]
+
+    operations = [migrations.RunPython(
+        add_aa_team_token, remove_aa_team_token)]

allianceauth/analytics/migrations/0009_remove_analyticstokens_ignore_paths_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 4.0.10 on 2023-05-08 05:24
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('analytics', '0008_add_AA_GA-4_Team_Token '),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='analyticstokens',
+            name='ignore_paths',
+        ),
+        migrations.RemoveField(
+            model_name='analyticstokens',
+            name='send_celery_tasks',
+        ),
+        migrations.RemoveField(
+            model_name='analyticstokens',
+            name='send_page_views',
+        ),
+        migrations.DeleteModel(
+            name='AnalyticsPath',
+        ),
+    ]

allianceauth/analytics/migrations/0010_alter_analyticsidentifier_options.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.16 on 2024-12-11 02:17
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('analytics', '0009_remove_analyticstokens_ignore_paths_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='analyticsidentifier',
+            options={'verbose_name': 'Analytics Identifier'},
+        ),
+    ]

allianceauth/analytics/migrations/0011_v5squash.py

@@ -0,0 +1,56 @@
+# Generated by Django 5.1.6 on 2025-03-04 01:03
+
+# This was built by Deleting Every Migration, Creating one from scratch
+# And porting in anything necessary
+
+import uuid
+
+from django.db import migrations, models
+
+
+def add_aa_team_token(apps, schema_editor):
+    Tokens = apps.get_model('analytics', 'AnalyticsTokens')
+    token = Tokens()
+
+    token.type = 'GA-V4'
+    token.token = 'G-6LYSMYK8DE'
+    token.secret = 'KLlpjLZ-SRGozS5f5wb_kw'
+    token.name = 'AA Team Public Google Analytics (V4)'
+    token.save()
+
+
+class Migration(migrations.Migration):
+
+    replaces = [('analytics', '0001_initial'), ('analytics', '0002_add_AA_Team_Token'), ('analytics', '0003_Generate_Identifier'), ('analytics', '0004_auto_20211015_0502'), ('analytics', '0005_alter_analyticspath_ignore_path'), ('analytics', '0006_more_ignore_paths'), ('analytics', '0007_analyticstokens_secret'), ('analytics', '0008_add_AA_GA-4_Team_Token '), ('analytics', '0009_remove_analyticstokens_ignore_paths_and_more'), ('analytics', '0010_alter_analyticsidentifier_options')]
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AnalyticsIdentifier',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('identifier', models.UUIDField(default=uuid.uuid4, editable=False)),
+            ],
+            options={
+                'verbose_name': 'Analytics Identifier',
+            },
+        ),
+        migrations.CreateModel(
+            name='AnalyticsTokens',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=254)),
+                ('type', models.CharField(choices=[('GA-U', 'Google Analytics Universal'), ('GA-V4', 'Google Analytics V4')], max_length=254)),
+                ('token', models.CharField(max_length=254)),
+                ('secret', models.CharField(blank=True, max_length=254)),
+                ('send_stats', models.BooleanField(default=False)),
+            ],
+        ),
+        migrations.RunPython(
+            add_aa_team_token
+        ),
+    ]

allianceauth/analytics/models.py

@@ -1,26 +1,21 @@
-from django.db import models
-from django.core.exceptions import ValidationError
-from django.utils.translation import gettext_lazy as _
-
+from typing import Literal
 from uuid import uuid4
 
+from solo.models import SingletonModel
 
-class AnalyticsIdentifier(models.Model):
-
-    identifier = models.UUIDField(default=uuid4,
-                                  editable=False)
-
-    def save(self, *args, **kwargs):
-        if not self.pk and AnalyticsIdentifier.objects.exists():
-            # Force a single object
-            raise ValidationError('There is can be only one \
-                                   AnalyticsIdentifier instance')
-        self.pk = self.id = 1 # If this happens to be deleted and recreated, force it to be 1
-        return super().save(*args, **kwargs)
+from django.db import models
+from django.utils.translation import gettext_lazy as _
 
 
-class AnalyticsPath(models.Model):
-    ignore_path = models.CharField(max_length=254, default="/example/", help_text="Regex Expression, If matched no Analytics Page View is sent")
+class AnalyticsIdentifier(SingletonModel):
+
+    identifier = models.UUIDField(default=uuid4, editable=False)
+
+    def __str__(self) -> Literal['Analytics Identifier']:
+        return "Analytics Identifier"
+
+    class Meta:
+        verbose_name = "Analytics Identifier"
 
 
 class AnalyticsTokens(models.Model):
@@ -32,7 +27,8 @@ class AnalyticsTokens(models.Model):
     name = models.CharField(max_length=254)
     type = models.CharField(max_length=254, choices=Analytics_Type.choices)
     token = models.CharField(max_length=254, blank=False)
-    send_page_views = models.BooleanField(default=False)
-    send_celery_tasks = models.BooleanField(default=False)
+    secret = models.CharField(max_length=254, blank=True)
     send_stats = models.BooleanField(default=False)
-    ignore_paths = models.ManyToManyField(AnalyticsPath, blank=True)
+
+    def __str__(self) -> str:
+        return self.name

allianceauth/analytics/signals.py

@@ -1,55 +0,0 @@
-import logging
-from celery.signals import task_failure, task_success
-from django.conf import settings
-from allianceauth.analytics.tasks import analytics_event
-
-logger = logging.getLogger(__name__)
-
-
-@task_failure.connect
-def process_failure_signal(
-                        exception, traceback,
-                        sender, task_id, signal,
-                        args, kwargs, einfo, **kw):
-    logger.debug("Celery task_failure signal %s" % sender.__class__.__name__)
-    if getattr(settings, "ANALYTICS_DISABLED", False):
-        return
-
-    category = sender.__module__
-
-    if 'allianceauth.analytics' not in category:
-        if category.endswith(".tasks"):
-            category = category[:-6]
-
-        action = sender.__name__
-
-        label = f"{exception.__class__.__name__}"
-
-        analytics_event(category=category,
-                        action=action,
-                        label=label)
-
-
-@task_success.connect
-def celery_success_signal(sender, result=None, **kw):
-    logger.debug("Celery task_success signal %s" % sender.__class__.__name__)
-    if getattr(settings, "ANALYTICS_DISABLED", False):
-        return
-
-    category = sender.__module__
-
-    if 'allianceauth.analytics' not in category:
-        if category.endswith(".tasks"):
-            category = category[:-6]
-
-        action = sender.__name__
-        label = "Success"
-
-        value = 0
-        if isinstance(result, int):
-            value = result
-
-        analytics_event(category=category,
-                        action=action,
-                        label=label,
-                        value=value)

allianceauth/analytics/tasks.py

@@ -1,25 +1,26 @@
-import requests
 import logging
-from django.conf import settings
-from django.apps import apps
+
+import requests
 from celery import shared_task
+
+from django.apps import apps
+from django.conf import settings
+
 from allianceauth import __version__
-from .models import AnalyticsTokens, AnalyticsIdentifier
-from .utils import (
-    install_stat_addons,
-    install_stat_tokens,
-    install_stat_users)
+
+from .models import AnalyticsIdentifier, AnalyticsTokens
+from .utils import existence_baremetal_or_docker, install_stat_addons, install_stat_tokens, install_stat_users
 
 logger = logging.getLogger(__name__)
 
-BASE_URL = "https://www.google-analytics.com/"
+BASE_URL = "https://www.google-analytics.com"
 
-DEBUG_URL = f"{BASE_URL}debug/collect"
-COLLECTION_URL = f"{BASE_URL}collect"
+DEBUG_URL = f"{BASE_URL}/debug/mp/collect"
+COLLECTION_URL = f"{BASE_URL}/mp/collect"
 
 if getattr(settings, "ANALYTICS_ENABLE_DEBUG", False) and settings.DEBUG:
-    # Force sending of analytics data during in a debug/test environemt
-    # Usefull for developers working on this feature.
+    # Force sending of analytics data during in a debug/test environment
+    # Useful for developers working on this feature.
     logger.warning(
         "You have 'ANALYTICS_ENABLE_DEBUG' Enabled! "
         "This debug instance will send analytics data!")
@@ -31,177 +32,175 @@ if settings.DEBUG is True:
     ANALYTICS_URL = DEBUG_URL
 
 
-def analytics_event(category: str,
-                    action: str,
-                    label: str,
-                    value: int = 0,
+def analytics_event(namespace: str,
+                    task: str,
+                    label: str = "",
+                    result: str = "",
+                    value: int = 1,
                     event_type: str = 'Celery'):
     """
     Send a Google Analytics Event for each token stored
     Includes check for if its enabled/disabled
 
     Args:
-        `category` (str): Celery Namespace
-        `action` (str): Task Name
-        `label` (str): Optional, Task Success/Exception
-        `value` (int): Optional, If bulk, Query size, can be a binary True/False
+        `namespace` (str): Celery Namespace
+        `task` (str): Task Name
+        `label` (str): Optional, additional task label
+        `result` (str): Optional, Task Success/Exception
+        `value` (int): Optional, If bulk, Query size, can be a Boolean
         `event_type` (str): Optional, Celery or Stats only, Default to Celery
     """
-    analyticstokens = AnalyticsTokens.objects.all()
-    client_id = AnalyticsIdentifier.objects.get(id=1).identifier.hex
-    for token in analyticstokens:
-        if event_type == 'Celery':
-            allowed = token.send_celery_tasks
-        elif event_type == 'Stats':
+    for token in AnalyticsTokens.objects.filter(type='GA-V4'):
+        if event_type == 'Stats':
             allowed = token.send_stats
         else:
             allowed = False
 
         if allowed is True:
-            tracking_id = token.token
             send_ga_tracking_celery_event.s(
-                tracking_id=tracking_id,
-                client_id=client_id,
-                category=category,
-                action=action,
+                measurement_id=token.token,
+                secret=token.secret,
+                namespace=namespace,
+                task=task,
                 label=label,
+                result=result,
                 value=value).apply_async(priority=9)
 
 
-@shared_task()
-def analytics_daily_stats():
+@shared_task
+def analytics_daily_stats() -> None:
     """Celery Task: Do not call directly
 
-    Gathers a series of daily statistics and sends analytics events containing them
+    Gathers a series of daily statistics
+    Sends analytics events containing them
     """
     users = install_stat_users()
     tokens = install_stat_tokens()
     addons = install_stat_addons()
+    existence_type = existence_baremetal_or_docker()
     logger.debug("Running Daily Analytics Upload")
 
-    analytics_event(category='allianceauth.analytics',
-                    action='send_install_stats',
+    analytics_event(namespace='allianceauth.analytics',
+                    task='send_install_stats',
                     label='existence',
                     value=1,
                     event_type='Stats')
-    analytics_event(category='allianceauth.analytics',
-                    action='send_install_stats',
+    analytics_event(namespace='allianceauth.analytics',
+                    task='send_install_stats',
+                    label=existence_type,
+                    value=1,
+                    event_type='Stats')
+    analytics_event(namespace='allianceauth.analytics',
+                    task='send_install_stats',
                     label='users',
                     value=users,
                     event_type='Stats')
-    analytics_event(category='allianceauth.analytics',
-                    action='send_install_stats',
+    analytics_event(namespace='allianceauth.analytics',
+                    task='send_install_stats',
                     label='tokens',
                     value=tokens,
                     event_type='Stats')
-    analytics_event(category='allianceauth.analytics',
-                    action='send_install_stats',
+    analytics_event(namespace='allianceauth.analytics',
+                    task='send_install_stats',
                     label='addons',
                     value=addons,
                     event_type='Stats')
-
     for appconfig in apps.get_app_configs():
-        analytics_event(category='allianceauth.analytics',
-                        action='send_extension_stats',
-                        label=appconfig.label,
-                        value=1,
-                        event_type='Stats')
+        if appconfig.label in [
+            "django_celery_beat",
+            "bootstrapform",
+            "messages",
+            "sessions",
+            "auth",
+            "staticfiles",
+            "users",
+            "addons",
+            "admin",
+            "humanize",
+            "contenttypes",
+            "sortedm2m",
+            "django_bootstrap5",
+            "tokens",
+            "authentication",
+            "services",
+            "framework",
+            "notifications"
+            "eveonline",
+            "navhelper",
+            "analytics",
+            "menu",
+            "theme"
+        ]:
+            pass
+        else:
+            analytics_event(namespace='allianceauth.analytics',
+                            task='send_extension_stats',
+                            label=appconfig.label,
+                            value=1,
+                            event_type='Stats')
 
 
-@shared_task()
-def send_ga_tracking_web_view(
-                            tracking_id: str,
-                            client_id: str,
-                            page: str,
-                            title: str,
-                            locale: str,
-                            useragent: str) -> requests.Response:
-
-    """Celery Task: Do not call directly
-
-    Sends Page View events to GA, Called only via analytics.middleware
-
-    Parameters
-    ----------
-    `tracking_id` (str): Unique Server Identifier
-    `client_id` (str): GA Token
-    `page` (str): Page Path
-    `title` (str): Page Title
-    `locale` (str): Browser Language
-    `useragent` (str): Browser UserAgent
-
-    Returns
-    -------
-    requests.Reponse Object
-    """
-    headers = {"User-Agent": useragent}
-
-    payload = {
-            'v': '1',
-            'tid': tracking_id,
-            'cid': client_id,
-            't': 'pageview',
-            'dp': page,
-            'dt': title,
-            'ul': locale,
-            'ua': useragent,
-            'aip': 1,
-            'an': "allianceauth",
-            'av': __version__
-            }
-
-    response = requests.post(
-                        ANALYTICS_URL, data=payload,
-                        timeout=5, headers=headers)
-    logger.debug(f"Analytics Page View HTTP{response.status_code}")
-    return response
-
-
-@shared_task()
+@shared_task
 def send_ga_tracking_celery_event(
-                                tracking_id: str,
-                                client_id: str,
-                                category: str,
-                                action: str,
-                                label: str,
-                                value: int) -> requests.Response:
+        measurement_id: str,
+        secret: str,
+        namespace: str,
+        task: str,
+        label: str = "",
+        result: str = "",
+        value: int = 1):
     """Celery Task: Do not call directly
 
-    Sends Page View events to GA, Called only via analytics.middleware
+    Sends an events to GA
 
     Parameters
     ----------
-    `tracking_id` (str): Unique Server Identifier
-    `client_id` (str): GA Token
-    `category` (str): Celery Namespace
-    `action` (str): Task Name
-    `label` (str): Optional, Task Success/Exception
+    `measurement_id` (str): GA Token
+    `secret` (str): GA Authentication Secret
+    `namespace` (str): Celery Namespace
+    `task` (str): Task Name
+    `label` (str): Optional, additional task label
+    `result` (str): Optional, Task Success/Exception
     `value` (int): Optional, If bulk, Query size, can be a binary True/False
-
-    Returns
-    -------
-    requests.Reponse Object
     """
 
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"}
+    parameters = {
+        'measurement_id': measurement_id,
+        'api_secret': secret
+    }
 
     payload = {
-            'v': '1',
-            'tid': tracking_id,
-            'cid': client_id,
-            't': 'event',
-            'ec': category,
-            'ea': action,
-            'el': label,
-            'ev': value,
-            'aip': 1,
-            'an': "allianceauth",
-            'av': __version__
+        'client_id': AnalyticsIdentifier.get_solo().identifier.hex,
+        "user_properties": {
+            "allianceauth_version": {
+                "value": __version__
             }
-
-    response = requests.post(
-                        ANALYTICS_URL, data=payload,
-                        timeout=5, headers=headers)
-    logger.debug(f"Analytics Celery/Stats Event HTTP{response.status_code}")
-    return response
+        },
+        'non_personalized_ads': True,
+        "events": [{
+            "name": "celery_event",
+            "params": {
+                    "namespace": namespace,
+                    "task": task,
+                    'result': result,
+                    'label': label,
+                    "value": value
+            }
+        }]
+    }
+    try:
+        response = requests.post(
+            ANALYTICS_URL,
+            params=parameters,
+            json=payload,
+            timeout=10)
+        response.raise_for_status()
+        logger.debug(
+            f"Analytics Celery/Stats Event HTTP{response.status_code}")
+        return response.status_code
+    except requests.exceptions.HTTPError as e:
+        logger.debug(e)
+        return response.status_code
+    except requests.exceptions.ConnectionError as e:
+        logger.debug(e)
+        return "Failed"

allianceauth/analytics/tests/test_integration.py

@@ -1,108 +0,0 @@
-from unittest.mock import patch
-from urllib.parse import parse_qs
-
-import requests_mock
-
-from django.test import TestCase, override_settings
-
-from allianceauth.analytics.tasks import ANALYTICS_URL
-from allianceauth.eveonline.tasks import update_character
-from allianceauth.tests.auth_utils import AuthUtils
-
-
-@override_settings(CELERY_ALWAYS_EAGER=True)
-@requests_mock.mock()
-class TestAnalyticsForViews(TestCase):
-    @override_settings(ANALYTICS_DISABLED=False)
-    def test_should_run_analytics(self, requests_mocker):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        user = AuthUtils.create_user("Bruce Wayne")
-        self.client.force_login(user)
-        # when
-        response = self.client.get("/dashboard/")
-        # then
-        self.assertEqual(response.status_code, 200)
-        self.assertTrue(requests_mocker.called)
-
-    @override_settings(ANALYTICS_DISABLED=True)
-    def test_should_not_run_analytics(self, requests_mocker):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        user = AuthUtils.create_user("Bruce Wayne")
-        self.client.force_login(user)
-        # when
-        response = self.client.get("/dashboard/")
-        # then
-        self.assertEqual(response.status_code, 200)
-        self.assertFalse(requests_mocker.called)
-
-
-@override_settings(CELERY_ALWAYS_EAGER=True)
-@requests_mock.mock()
-class TestAnalyticsForTasks(TestCase):
-    @override_settings(ANALYTICS_DISABLED=False)
-    @patch("allianceauth.eveonline.models.EveCharacter.objects.update_character")
-    def test_should_run_analytics_for_successful_task(
-        self, requests_mocker, mock_update_character
-    ):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        user = AuthUtils.create_user("Bruce Wayne")
-        character = AuthUtils.add_main_character_2(user, "Bruce Wayne", 1001)
-        # when
-        update_character.delay(character.character_id)
-        # then
-        self.assertTrue(mock_update_character.called)
-        self.assertTrue(requests_mocker.called)
-        payload = parse_qs(requests_mocker.last_request.text)
-        self.assertListEqual(payload["el"], ["Success"])
-
-    @override_settings(ANALYTICS_DISABLED=True)
-    @patch("allianceauth.eveonline.models.EveCharacter.objects.update_character")
-    def test_should_not_run_analytics_for_successful_task(
-        self, requests_mocker, mock_update_character
-    ):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        user = AuthUtils.create_user("Bruce Wayne")
-        character = AuthUtils.add_main_character_2(user, "Bruce Wayne", 1001)
-        # when
-        update_character.delay(character.character_id)
-        # then
-        self.assertTrue(mock_update_character.called)
-        self.assertFalse(requests_mocker.called)
-
-    @override_settings(ANALYTICS_DISABLED=False)
-    @patch("allianceauth.eveonline.models.EveCharacter.objects.update_character")
-    def test_should_run_analytics_for_failed_task(
-        self, requests_mocker, mock_update_character
-    ):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        mock_update_character.side_effect = RuntimeError
-        user = AuthUtils.create_user("Bruce Wayne")
-        character = AuthUtils.add_main_character_2(user, "Bruce Wayne", 1001)
-        # when
-        update_character.delay(character.character_id)
-        # then
-        self.assertTrue(mock_update_character.called)
-        self.assertTrue(requests_mocker.called)
-        payload = parse_qs(requests_mocker.last_request.text)
-        self.assertNotEqual(payload["el"], ["Success"])
-
-    @override_settings(ANALYTICS_DISABLED=True)
-    @patch("allianceauth.eveonline.models.EveCharacter.objects.update_character")
-    def test_should_not_run_analytics_for_failed_task(
-        self, requests_mocker, mock_update_character
-    ):
-        # given
-        requests_mocker.post(ANALYTICS_URL)
-        mock_update_character.side_effect = RuntimeError
-        user = AuthUtils.create_user("Bruce Wayne")
-        character = AuthUtils.add_main_character_2(user, "Bruce Wayne", 1001)
-        # when
-        update_character.delay(character.character_id)
-        # then
-        self.assertTrue(mock_update_character.called)
-        self.assertFalse(requests_mocker.called)

allianceauth/analytics/tests/test_middleware.py

@@ -1,23 +0,0 @@
-from allianceauth.analytics.middleware import AnalyticsMiddleware
-from unittest.mock import Mock
-
-from django.test.testcases import TestCase
-
-
-class TestAnalyticsMiddleware(TestCase):
-
-    def setUp(self):
-        self.middleware = AnalyticsMiddleware()
-        self.request = Mock()
-        self.request.headers = {
-                "User-Agent": "AUTOMATED TEST"
-            }
-        self.request.path = '/testURL/'
-        self.request.session = {}
-        self.request.LANGUAGE_CODE = 'en'
-        self.response = Mock()
-        self.response.content = 'hello world'
-
-    def test_middleware(self):
-        response = self.middleware.process_response(self.request, self.response)
-        self.assertEqual(self.response, response)

allianceauth/analytics/tests/test_models.py

@@ -1,10 +1,8 @@
-from allianceauth.analytics.models import AnalyticsIdentifier
-from django.core.exceptions import ValidationError
+from uuid import uuid4
 
 from django.test.testcases import TestCase
 
-from uuid import UUID, uuid4
-
+from allianceauth.analytics.models import AnalyticsIdentifier
 
 # Identifiers
 uuid_1 = "ab33e241fbf042b6aa77c7655a768af7"
@@ -14,13 +12,4 @@ uuid_2 = "7aa6bd70701f44729af5e3095ff4b55c"
 class TestAnalyticsIdentifier(TestCase):
 
     def test_identifier_random(self):
-        self.assertNotEqual(AnalyticsIdentifier.objects.get(), uuid4)
-
-    def test_identifier_singular(self):
-        AnalyticsIdentifier.objects.all().delete()
-        AnalyticsIdentifier.objects.create(identifier=uuid_1)
-        # Yeah i have multiple asserts here, they all do the same thing
-        with self.assertRaises(ValidationError):
-            AnalyticsIdentifier.objects.create(identifier=uuid_2)
-        self.assertEqual(AnalyticsIdentifier.objects.count(), 1)
-        self.assertEqual(AnalyticsIdentifier.objects.get(pk=1).identifier, UUID(uuid_1))
+        self.assertNotEqual(AnalyticsIdentifier.get_solo(), uuid4)

allianceauth/analytics/tests/test_tasks.py

@@ -1,119 +1,66 @@
-from allianceauth.analytics.tasks import (
-    analytics_event,
-    send_ga_tracking_celery_event,
-    send_ga_tracking_web_view)
-from django.test.testcases import TestCase
+import requests_mock
+
+from django.test.utils import override_settings
+
+from allianceauth.analytics.tasks import analytics_event, send_ga_tracking_celery_event
+from allianceauth.utils.testing import NoSocketsTestCase
+
+GOOGLE_ANALYTICS_DEBUG_URL = 'https://www.google-analytics.com/debug/mp/collect'
 
 
-class TestAnalyticsTasks(TestCase):
-    def test_analytics_event(self):
+@override_settings(CELERY_ALWAYS_EAGER=True, CELERY_EAGER_PROPAGATES_EXCEPTIONS=True)
+@requests_mock.Mocker()
+class TestAnalyticsTasks(NoSocketsTestCase):
+    def test_analytics_event(self, requests_mocker):
+        requests_mocker.register_uri('POST', GOOGLE_ANALYTICS_DEBUG_URL)
         analytics_event(
-                        category='allianceauth.analytics',
-                        action='send_tests',
-                        label='test',
-                        value=1,
-                        event_type='Stats')
+            namespace='allianceauth.analytics',
+            task='send_tests',
+            label='test',
+            value=1,
+            result="Success",
+            event_type='Stats')
 
-    def test_send_ga_tracking_web_view_sent(self):
-        # This test sends if the event SENDS to google
-        # Not if it was successful
-        tracking_id = 'UA-186249766-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
-        page = '/index/'
-        title = 'Hello World'
-        locale = 'en'
-        useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
-        response = send_ga_tracking_web_view(
-                                            tracking_id,
-                                            client_id,
-                                            page,
-                                            title,
-                                            locale,
-                                            useragent)
-        self.assertEqual(response.status_code, 200)
-
-    def test_send_ga_tracking_web_view_success(self):
-        tracking_id = 'UA-186249766-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
-        page = '/index/'
-        title = 'Hello World'
-        locale = 'en'
-        useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
-        json_response = send_ga_tracking_web_view(
-                                                tracking_id,
-                                                client_id,
-                                                page,
-                                                title,
-                                                locale,
-                                                useragent).json()
-        self.assertTrue(json_response["hitParsingResult"][0]["valid"])
-
-    def test_send_ga_tracking_web_view_invalid_token(self):
-        tracking_id = 'UA-IntentionallyBadTrackingID-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
-        page = '/index/'
-        title = 'Hello World'
-        locale = 'en'
-        useragent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
-        json_response = send_ga_tracking_web_view(
-                                            tracking_id,
-                                            client_id,
-                                            page,
-                                            title,
-                                            locale,
-                                            useragent).json()
-        self.assertFalse(json_response["hitParsingResult"][0]["valid"])
-        self.assertEqual(json_response["hitParsingResult"][0]["parserMessage"][1]["description"], "The value provided for parameter 'tid' is invalid. Please see http://goo.gl/a8d4RP#tid for details.")
-
-        # [{'valid': False, 'parserMessage': [{'messageType': 'INFO', 'description': 'IP Address from this hit was anonymized to 1.132.110.0.', 'messageCode': 'VALUE_MODIFIED'}, {'messageType': 'ERROR', 'description': "The value provided for parameter 'tid' is invalid. Please see http://goo.gl/a8d4RP#tid for details.", 'messageCode': 'VALUE_INVALID', 'parameter': 'tid'}], 'hit': '/debug/collect?v=1&tid=UA-IntentionallyBadTrackingID-2&cid=ab33e241fbf042b6aa77c7655a768af7&t=pageview&dp=/index/&dt=Hello World&ul=en&ua=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36&aip=1&an=allianceauth&av=2.9.0a2'}]
-
-    def test_send_ga_tracking_celery_event_sent(self):
-        tracking_id = 'UA-186249766-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
+    def test_send_ga_tracking_celery_event_sent(self, requests_mocker):
+        # given
+        requests_mocker.register_uri('POST', GOOGLE_ANALYTICS_DEBUG_URL)
+        token = 'G-6LYSMYK8DE'
+        secret = 'KLlpjLZ-SRGozS5f5wb_kw',
         category = 'test'
         action = 'test'
         label = 'test'
         value = '1'
-        response = send_ga_tracking_celery_event(
-                                                tracking_id,
-                                                client_id,
-                                                category,
-                                                action,
-                                                label,
-                                                value)
-        self.assertEqual(response.status_code, 200)
+        # when
+        task = send_ga_tracking_celery_event(
+            token,
+            secret,
+            category,
+            action,
+            label,
+            value)
+        # then
+        self.assertEqual(task, 200)
 
-    def test_send_ga_tracking_celery_event_success(self):
-        tracking_id = 'UA-186249766-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
+    def test_send_ga_tracking_celery_event_success(self, requests_mocker):
+        # given
+        requests_mocker.register_uri(
+            'POST',
+            GOOGLE_ANALYTICS_DEBUG_URL,
+            json={"validationMessages": []}
+        )
+        token = 'G-6LYSMYK8DE'
+        secret = 'KLlpjLZ-SRGozS5f5wb_kw',
         category = 'test'
         action = 'test'
         label = 'test'
         value = '1'
-        json_response = send_ga_tracking_celery_event(
-                                                    tracking_id,
-                                                    client_id,
-                                                    category,
-                                                    action,
-                                                    label,
-                                                    value).json()
-        self.assertTrue(json_response["hitParsingResult"][0]["valid"])
-
-    def test_send_ga_tracking_celery_event_invalid_token(self):
-        tracking_id = 'UA-IntentionallyBadTrackingID-2'
-        client_id = 'ab33e241fbf042b6aa77c7655a768af7'
-        category = 'test'
-        action = 'test'
-        label = 'test'
-        value = '1'
-        json_response = send_ga_tracking_celery_event(
-                                                    tracking_id,
-                                                    client_id,
-                                                    category,
-                                                    action,
-                                                    label,
-                                                    value).json()
-        self.assertFalse(json_response["hitParsingResult"][0]["valid"])
-        self.assertEqual(json_response["hitParsingResult"][0]["parserMessage"][1]["description"], "The value provided for parameter 'tid' is invalid. Please see http://goo.gl/a8d4RP#tid for details.")
-
-        # [{'valid': False, 'parserMessage': [{'messageType': 'INFO', 'description': 'IP Address from this hit was anonymized to 1.132.110.0.', 'messageCode': 'VALUE_MODIFIED'}, {'messageType': 'ERROR', 'description': "The value provided for parameter 'tid' is invalid. Please see http://goo.gl/a8d4RP#tid for details.", 'messageCode': 'VALUE_INVALID', 'parameter': 'tid'}], 'hit': '/debug/collect?v=1&tid=UA-IntentionallyBadTrackingID-2&cid=ab33e241fbf042b6aa77c7655a768af7&t=pageview&dp=/index/&dt=Hello World&ul=en&ua=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36&aip=1&an=allianceauth&av=2.9.0a2'}]
+        # when
+        task = send_ga_tracking_celery_event(
+            token,
+            secret,
+            category,
+            action,
+            label,
+            value)
+        # then
+        self.assertTrue(task, 200)

allianceauth/analytics/tests/test_utils.py

@@ -1,10 +1,9 @@
 from django.apps import apps
-from allianceauth.authentication.models import User
-from esi.models import Token
-from allianceauth.analytics.utils import install_stat_users, install_stat_tokens, install_stat_addons
-
 from django.test.testcases import TestCase
 
+from allianceauth.analytics.utils import install_stat_addons, install_stat_users
+from allianceauth.authentication.models import User
+
 
 def create_testdata():
     User.objects.all().delete()
@@ -18,17 +17,17 @@ def create_testdata():
         'abc@example.com',
         'password'
     )
-    #Token.objects.all().delete()
-    #Token.objects.create(
+    # Token.objects.all().delete()
+    # Token.objects.create(
     #            character_id=101,
     #            character_name='character1',
     #            access_token='my_access_token'
-    #)
-    #Token.objects.create(
+    # )
+    # Token.objects.create(
     #            character_id=102,
     #            character_name='character2',
     #            access_token='my_access_token'
-    #)
+    # )
 
 
 class TestAnalyticsUtils(TestCase):
@@ -40,7 +39,7 @@ class TestAnalyticsUtils(TestCase):
         users = install_stat_users()
         self.assertEqual(users, expected)
 
-    #def test_install_stat_tokens(self):
+    # def test_install_stat_tokens(self):
     #    create_testdata()
     #    expected = 2
     #

allianceauth/analytics/utils.py

@@ -1,7 +1,11 @@
+import os
+
 from django.apps import apps
-from allianceauth.authentication.models import User
+
 from esi.models import Token
 
+from allianceauth.authentication.models import User
+
 
 def install_stat_users() -> int:
     """Count and Return the number of User accounts
@@ -34,3 +38,16 @@ def install_stat_addons() -> int:
         The Number of Installed Apps"""
     addons = len(list(apps.get_app_configs()))
     return addons
+
+
+def existence_baremetal_or_docker() -> str:
+    """Checks the Installation Type of an install
+
+    Returns
+    -------
+    str
+        existence_baremetal or existence_docker"""
+    docker_tag = os.getenv('AA_DOCKER_TAG')
+    if docker_tag:
+        return "existence_docker"
+    return "existence_baremetal"

allianceauth/apps.py

@@ -3,3 +3,6 @@ from django.apps import AppConfig
 
 class AllianceAuthConfig(AppConfig):
     name = 'allianceauth'
+
+    def ready(self) -> None:
+        import allianceauth.checks # noqa

allianceauth/authentication/__init__.py

@@ -1 +0,0 @@
-default_app_config = 'allianceauth.authentication.apps.AuthenticationConfig'

allianceauth/authentication/admin.py

@@ -1,43 +1,21 @@
 from django.contrib import admin
 from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
-from django.contrib.auth.models import Group
-from django.contrib.auth.models import Permission as BasePermission
-from django.contrib.auth.models import User as BaseUser
+from django.contrib.auth.models import Group, Permission as BasePermission, User as BaseUser
 from django.db.models import Count, Q
 from django.db.models.functions import Lower
-from django.db.models.signals import (
-    m2m_changed,
-    post_delete,
-    post_save,
-    pre_delete,
-    pre_save
-)
+from django.db.models.signals import m2m_changed, post_delete, post_save, pre_delete, pre_save
 from django.dispatch import receiver
 from django.urls import reverse
 from django.utils.html import format_html
 from django.utils.text import slugify
 
-from allianceauth.authentication.models import (
-    CharacterOwnership,
-    OwnershipRecord,
-    State,
-    UserProfile,
-    get_guest_state
-)
-from allianceauth.eveonline.models import (
-    EveAllianceInfo,
-    EveCharacter,
-    EveCorporationInfo,
-    EveFactionInfo
-)
+from allianceauth.authentication.models import CharacterOwnership, OwnershipRecord, State, UserProfile, get_guest_state
+from allianceauth.eveonline.models import EveAllianceInfo, EveCharacter, EveCorporationInfo, EveFactionInfo
 from allianceauth.eveonline.tasks import update_character
 from allianceauth.hooks import get_hooks
 from allianceauth.services.hooks import ServicesHook
 
-from .app_settings import (
-    AUTHENTICATION_ADMIN_USERS_MAX_CHARS,
-    AUTHENTICATION_ADMIN_USERS_MAX_GROUPS
-)
+from .app_settings import AUTHENTICATION_ADMIN_USERS_MAX_CHARS, AUTHENTICATION_ADMIN_USERS_MAX_GROUPS
 from .forms import UserChangeForm, UserProfileForm
 
 
@@ -132,10 +110,7 @@ def user_username(obj):
     To be used for all user based admin lists
     """
     link = reverse(
-        'admin:{}_{}_change'.format(
-            obj._meta.app_label,
-            type(obj).__name__.lower()
-        ),
+        f'admin:{obj._meta.app_label}_{type(obj).__name__.lower()}_change',
         args=(obj.pk,)
     )
     user_obj = obj.user if hasattr(obj, 'user') else obj
@@ -288,7 +263,7 @@ class UserAdmin(BaseUserAdmin):
     Behavior of groups and characters columns can be configured via settings
     """
 
-    inlines = BaseUserAdmin.inlines + [UserProfileInline]
+    inlines = [UserProfileInline]
     ordering = ('username', )
     list_select_related = ('profile__state', 'profile__main_character')
     show_full_result_count = True
@@ -322,7 +297,7 @@ class UserAdmin(BaseUserAdmin):
 
     class Media:
         css = {
-            "all": ("authentication/css/admin.css",)
+            "all": ("allianceauth/authentication/css/admin.css",)
         }
 
     def get_queryset(self, request):
@@ -542,13 +517,13 @@ class BaseOwnershipAdmin(admin.ModelAdmin):
 
     class Media:
         css = {
-            "all": ("authentication/css/admin.css",)
+            "all": ("allianceauth/authentication/css/admin.css",)
         }
 
     def get_readonly_fields(self, request, obj=None):
         if obj and obj.pk:
             return 'owner_hash', 'character'
-        return tuple()
+        return ()
 
 
 @admin.register(OwnershipRecord)

allianceauth/authentication/app_settings.py

@@ -25,7 +25,7 @@ def _clean_setting(
     if not required_type:
         required_type = type(default_value)
 
-    if min_value is None and required_type == int:
+    if min_value is None and required_type is int:
         min_value = 0
 
     if (hasattr(settings, name)

allianceauth/authentication/apps.py

@@ -1,10 +1,12 @@
 from django.apps import AppConfig
 from django.core.checks import register, Tags
+from django.utils.translation import gettext_lazy as _
 
 
 class AuthenticationConfig(AppConfig):
     name = "allianceauth.authentication"
     label = "authentication"
+    verbose_name = _("Authentication")
 
     def ready(self):
         from allianceauth.authentication import checks, signals  # noqa: F401

allianceauth/authentication/auth_hooks.py

@@ -0,0 +1,60 @@
+from allianceauth import hooks
+from allianceauth.hooks import DashboardItemHook
+
+from .views import dashboard_admin, dashboard_characters, dashboard_esi_check, dashboard_groups
+
+
+class UserCharactersHook(DashboardItemHook):
+    def __init__(self):
+        DashboardItemHook.__init__(
+            self,
+            dashboard_characters,
+            5
+        )
+
+
+class UserGroupsHook(DashboardItemHook):
+    def __init__(self):
+        DashboardItemHook.__init__(
+            self,
+            dashboard_groups,
+            5
+        )
+
+
+class AdminHook(DashboardItemHook):
+    def __init__(self):
+        DashboardItemHook.__init__(
+            self,
+            dashboard_admin,
+            1
+        )
+
+
+class ESICheckHook(DashboardItemHook):
+    def __init__(self):
+        DashboardItemHook.__init__(
+            self,
+            dashboard_esi_check,
+            0
+        )
+
+
+@hooks.register('dashboard_hook')
+def register_character_hook():
+    return UserCharactersHook()
+
+
+@hooks.register('dashboard_hook')
+def register_groups_hook():
+    return UserGroupsHook()
+
+
+@hooks.register('dashboard_hook')
+def register_admin_hook():
+    return AdminHook()
+
+
+@hooks.register('dashboard_hook')
+def register_esi_hook():
+    return ESICheckHook()

allianceauth/authentication/backends.py

@@ -1,10 +1,9 @@
 import logging
 
 from django.contrib.auth.backends import ModelBackend
-from django.contrib.auth.models import User, Permission
-
-from .models import UserProfile, CharacterOwnership, OwnershipRecord
+from django.contrib.auth.models import Permission, User
 
+from .models import CharacterOwnership, OwnershipRecord, UserProfile
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +36,11 @@ class StateBackend(ModelBackend):
             ownership = CharacterOwnership.objects.get(character__character_id=token.character_id)
             if ownership.owner_hash == token.character_owner_hash:
                 logger.debug(f'Authenticating {ownership.user} by ownership of character {token.character_name}')
-                return ownership.user
+                if ownership.user.profile.main_character:
+                    if ownership.user.profile.main_character.character_id == token.character_id:
+                        return ownership.user
+                    else:  # this is an alt, enforce main only.
+                        return None
             else:
                 logger.debug(f'{token.character_name} has changed ownership. Creating new user account.')
                 ownership.delete()
@@ -57,13 +60,18 @@ class StateBackend(ModelBackend):
                 if records.exists():
                     # we've seen this character owner before. Re-attach to their old user account
                     user = records[0].user
+                    if user.profile.main_character:
+                        if user.profile.main_character.character_id != token.character_id:
+                            # this is an alt, enforce main only due to trust issues in SSO.
+                            return None
+
                     token.user = user
                     co = CharacterOwnership.objects.create_by_token(token)
                     logger.debug(f'Authenticating {user} by matching owner hash record of character {co.character}')
-                    if not user.profile.main_character:
-                        # set this as their main by default if they have none
-                        user.profile.main_character = co.character
-                        user.profile.save()
+
+                    # set this as their main by default as they have none
+                    user.profile.main_character = co.character
+                    user.profile.save()
                     return user
             logger.debug(f'Unable to authenticate character {token.character_name}. Creating new user.')
             return self.create_user(token)

allianceauth/authentication/checks.py

@@ -1,5 +1,5 @@
-from django.core.checks import Error
 from django.conf import settings
+from django.core.checks import Error
 
 
 def check_login_scopes_setting(*args, **kwargs):

allianceauth/authentication/constants.py

@@ -0,0 +1,12 @@
+from django.utils.translation import gettext_lazy as _
+
+# Overide ESI messages in the dashboard widget
+# when the returned messages are not helpful or out of date
+ESI_ERROR_MESSAGE_OVERRIDES = {
+    420: _("This software has exceeded the error limit for ESI. "
+            "If you are a user, please contact the maintainer of this software."
+            " If you are a developer/maintainer, please make a greater "
+            "effort in the future to receive valid responses. For tips on how, "
+            "come have a chat with us in ##3rd-party-dev-and-esi on the EVE "
+            "Online Discord. https://www.eveonline.com/discord")
+}

allianceauth/authentication/core/celery_workers.py

@@ -0,0 +1,47 @@
+"""API for interacting with celery workers."""
+
+import itertools
+import logging
+
+from amqp.exceptions import ChannelError
+from celery import current_app
+
+from django.conf import settings
+
+logger = logging.getLogger(__name__)
+
+
+def active_tasks_count() -> int | None:
+    """Return count of currently active tasks
+    or None if celery workers are not online.
+    """
+    inspect = current_app.control.inspect()
+    return _tasks_count(inspect.active())
+
+
+def _tasks_count(data: dict) -> int | None:
+    """Return count of tasks in data from celery inspect API."""
+    try:
+        tasks = itertools.chain(*data.values())
+    except AttributeError:
+        return None
+    return len(list(tasks))
+
+
+def queued_tasks_count() -> int | None:
+    """Return count of queued tasks. Return None if there was an error."""
+    try:
+        with current_app.connection_or_acquire() as conn:
+            result = conn.default_channel.queue_declare(
+                queue=getattr(settings, "CELERY_DEFAULT_QUEUE", "celery"), passive=True
+            )
+            return result.message_count
+
+    except ChannelError:
+        # Queue doesn't exist, probably empty
+        return 0
+
+    except Exception:
+        logger.exception("Failed to get celery queue length")
+
+    return None

allianceauth/authentication/decorators.py

@@ -1,18 +1,28 @@
-from django.conf.urls import include
-from django.contrib.auth.decorators import user_passes_test
-from django.core.exceptions import PermissionDenied
+from collections.abc import Callable, Iterable
 from functools import wraps
-from django.shortcuts import redirect
+
 from django.contrib import messages
+from django.contrib.auth.decorators import login_required, user_passes_test
+from django.core.exceptions import PermissionDenied
+from django.shortcuts import redirect
+from django.urls import include
 from django.utils.translation import gettext_lazy as _
-from django.contrib.auth.decorators import login_required
 
 
 def user_has_main_character(user):
     return bool(user.profile.main_character)
 
 
-def decorate_url_patterns(urls, decorator):
+def decorate_url_patterns(
+    urls, decorator: Callable, excluded_views: Iterable | None = None
+):
+    """Decorate views given in url patterns except when they are explicitly excluded.
+
+    Args:
+        - urls: Django URL patterns
+        - decorator: Decorator to be added to each view
+        - exclude_views: Optional iterable of view names to be excluded
+    """
     url_list, app_name, namespace = include(urls)
 
     def process_patterns(url_patterns):
@@ -22,6 +32,8 @@ def decorate_url_patterns(urls, decorator):
                 process_patterns(pattern.url_patterns)
             else:
                 # this is a pattern
+                if excluded_views and pattern.lookup_str in excluded_views:
+                    return
                 pattern.callback = decorator(pattern.callback)
 
     process_patterns(url_list)

allianceauth/authentication/forms.py

@@ -60,7 +60,7 @@ class UserChangeForm(BaseUserChangeForm):
                     {
                         "groups": _(
                             "You are not allowed to add or remove these "
-                            "restricted groups: %s" % restricted_names
+                            "restricted groups: {}".format(restricted_names)
                         )
                     }
                 )

allianceauth/authentication/hmac_urls.py

@@ -1,14 +1,14 @@
-from django.conf.urls import url, include
+from django.urls import include, path, re_path
 
 from allianceauth.authentication import views
 
 urlpatterns = [
-    url(r'^activate/complete/$', views.activation_complete, name='registration_activation_complete'),
+    path('activate/complete/', views.activation_complete, name='registration_activation_complete'),
     # The activation key can make use of any character from the
     # URL-safe base64 alphabet, plus the colon as a separator.
-    url(r'^activate/(?P<activation_key>[-:\w]+)/$', views.ActivationView.as_view(), name='registration_activate'),
-    url(r'^register/$', views.RegistrationView.as_view(), name='registration_register'),
-    url(r'^register/complete/$', views.registration_complete, name='registration_complete'),
-    url(r'^register/closed/$', views.registration_closed, name='registration_disallowed'),
-    url(r'', include('django.contrib.auth.urls')),
+    re_path(r'^activate/(?P<activation_key>[-:\w]+)/$', views.ActivationView.as_view(), name='registration_activate'),
+    path('register/', views.RegistrationView.as_view(), name='registration_register'),
+    path('register/complete/', views.registration_complete, name='registration_complete'),
+    path('register/closed/', views.registration_closed, name='registration_disallowed'),
+    path('', include('django.contrib.auth.urls')),
 ]

allianceauth/authentication/management/commands/checkmains.py

@@ -1,4 +1,5 @@
 from django.core.management.base import BaseCommand
+
 from allianceauth.authentication.models import UserProfile
 
 
@@ -11,8 +12,7 @@ class Command(BaseCommand):
         if profiles.exists():
             for profile in profiles:
                 self.stdout.write(self.style.ERROR(
-                    '{} does not have an ownership. Resetting user {} main character.'.format(profile.main_character,
-                                                                                                profile.user)))
+                    f'{profile.main_character} does not have an ownership. Resetting user {profile.user} main character.'))
                 profile.main_character = None
                 profile.save()
             self.stdout.write(self.style.WARNING(f'Reset {profiles.count()} main characters.'))

allianceauth/authentication/managers.py

@@ -1,7 +1,7 @@
 import logging
 
 from django.db import transaction
-from django.db.models import Manager, QuerySet, Q
+from django.db.models import Manager, Q, QuerySet
 
 from allianceauth.eveonline.models import EveCharacter
 

allianceauth/authentication/middleware.py

@@ -0,0 +1,61 @@
+import logging
+
+from django.conf import settings
+from django.utils.deprecation import MiddlewareMixin
+
+logger = logging.getLogger(__name__)
+
+
+class UserSettingsMiddleware(MiddlewareMixin):
+    def process_response(self, request, response):
+        """Django Middleware: User Settings."""
+
+        # Intercept the built in django /setlang/ view and also save it to Database.
+        # Note the annoymous user check, only logged in users will ever hit the DB here
+        if request.path == '/i18n/setlang/' and not request.user.is_anonymous:
+            try:
+                request.user.profile.language = request.POST['language']
+                request.user.profile.save()
+            except Exception as e:
+                logger.exception(e)
+
+        # Only act during the login flow, _after_ user is activated (step 2: post-sso)
+        elif request.path == '/sso/login' and not request.user.is_anonymous:
+            # Set the Language Cookie, if it doesnt match the DB
+            # Null = hasnt been set by the user ever, dont act.
+            try:
+                if request.user.profile.language != request.LANGUAGE_CODE and request.user.profile.language is not None:
+                    response.set_cookie(key=settings.LANGUAGE_COOKIE_NAME,
+                                        value=request.user.profile.language,
+                                        max_age=settings.LANGUAGE_COOKIE_AGE)
+            except Exception as e:
+                logger.exception(e)
+
+            # AA v3 NIGHT_MODE
+            # Set our Night mode flag from the DB
+            # Null = hasnt been set by the user ever, dont act.
+            #
+            # Night mode intercept is not needed in this middleware.
+            # is saved direct to DB in NightModeRedirectView
+            try:
+                if request.user.profile.night_mode is not None:
+                    request.session["NIGHT_MODE"] = request.user.profile.night_mode
+            except Exception as e:
+                logger.exception(e)
+
+            # AA v4 Themes
+            # Null = has not been set by the user ever, dont act
+            # DEFAULT_THEME or DEFAULT_THEME_DARK will be used in get_theme()
+            try:
+                if request.user.profile.theme is not None:
+                    request.session["THEME"] = request.user.profile.theme
+            except Exception as e:
+                logger.exception(e)
+
+        # Minimize Menu
+        try:
+            request.session["MINIMIZE_SIDEBAR"] = request.user.profile.minimize_sidebar
+        except Exception as e:
+            pass  # We don't care that an anonymous user has no profile (not logged in)
+
+        return response

allianceauth/authentication/migrations/0001_initial.py

@@ -1,8 +1,8 @@
 # Generated by Django 1.10.1 on 2016-09-05 21:38
 
+import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
-import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

allianceauth/authentication/migrations/0004_create_permissions.py

@@ -2,6 +2,7 @@
 
 from django.db import migrations
 
+
 def create_permissions(apps, schema_editor):
     User = apps.get_model('auth', 'User')
     ContentType = apps.get_model('contenttypes', 'ContentType')

allianceauth/authentication/migrations/0005_delete_perms.py

@@ -2,6 +2,7 @@
 
 from django.db import migrations
 
+
 def delete_permissions(apps, schema_editor):
     User = apps.get_model('auth', 'User')
     ContentType = apps.get_model('contenttypes', 'ContentType')

allianceauth/authentication/migrations/0010_only_one_authservicesinfo.py

@@ -2,6 +2,7 @@
 
 from django.db import migrations
 
+
 def count_completed_fields(model):
     return len([True for key, value in model.__dict__.items() if bool(value)])
 

allianceauth/authentication/migrations/0011_authservicesinfo_user_onetoonefield.py

@@ -1,8 +1,8 @@
 # Generated by Django 1.10.1 on 2017-01-07 07:11
 
+import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
-import django.db.models.deletion
 
 
 class Migration(migrations.Migration):

allianceauth/authentication/migrations/0012_remove_add_delete_authservicesinfo_permissions.py

@@ -1,6 +1,7 @@
 # Generated by Django 1.10.5 on 2017-01-12 00:59
 
-from django.db import migrations, models
+from django.db import migrations
+
 
 def remove_permissions(apps, schema_editor):
     ContentType = apps.get_model('contenttypes', 'ContentType')

allianceauth/authentication/migrations/0013_service_modules.py

@@ -1,9 +1,9 @@
 # Generated by Django 1.10.2 on 2016-12-11 23:14
 
-from django.db import migrations
-
 import logging
 
+from django.db import migrations
+
 logger = logging.getLogger(__name__)
 
 

allianceauth/authentication/migrations/0015_user_profiles.py

@@ -1,11 +1,12 @@
 # Generated by Django 1.10.5 on 2017-03-22 23:09
 
-import allianceauth.authentication.models
 import django.db.models.deletion
 from django.conf import settings
 from django.contrib.auth.hashers import make_password
 from django.db import migrations, models
 
+import allianceauth.authentication.models
+
 
 def create_guest_state(apps, schema_editor):
     State = apps.get_model('authentication', 'State')

allianceauth/authentication/migrations/0016_ownershiprecord.py

@@ -1,8 +1,8 @@
 # Generated by Django 2.0.4 on 2018-04-14 18:28
 
+import django.db.models.deletion
 from django.conf import settings
 from django.db import migrations, models
-import django.db.models.deletion
 
 
 def create_initial_records(apps, schema_editor):

allianceauth/authentication/migrations/0020_userprofile_language_userprofile_night_mode.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.0.2 on 2022-02-26 03:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0019_merge_20211026_0919'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='language',
+            field=models.CharField(blank=True, choices=[('en', 'English'), ('de', 'German'), ('es', 'Spanish'), ('zh-hans', 'Chinese Simplified'), ('ru', 'Russian'), ('ko', 'Korean'), ('fr', 'French'), ('ja', 'Japanese'), ('it', 'Italian')], default='', max_length=10, verbose_name='Language'),
+        ),
+        migrations.AddField(
+            model_name='userprofile',
+            name='night_mode',
+            field=models.BooleanField(blank=True, null=True, verbose_name='Night Mode'),
+        ),
+    ]

allianceauth/authentication/migrations/0021_alter_userprofile_language.py

@@ -0,0 +1,34 @@
+# Generated by Django 4.0.10 on 2023-05-28 15:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("authentication", "0020_userprofile_language_userprofile_night_mode"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="userprofile",
+            name="language",
+            field=models.CharField(
+                blank=True,
+                choices=[
+                    ("en", "English"),
+                    ("de", "German"),
+                    ("es", "Spanish"),
+                    ("zh-hans", "Chinese Simplified"),
+                    ("ru", "Russian"),
+                    ("ko", "Korean"),
+                    ("fr", "French"),
+                    ("ja", "Japanese"),
+                    ("it", "Italian"),
+                    ("uk", "Ukrainian"),
+                ],
+                default="",
+                max_length=10,
+                verbose_name="Language",
+            ),
+        ),
+    ]

allianceauth/authentication/migrations/0022_userprofile_theme.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.0.10 on 2023-10-07 07:59
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0021_alter_userprofile_language'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='userprofile',
+            name='theme',
+            field=models.CharField(blank=True, help_text='Bootstrap 5 Themes from https://bootswatch.com/ or Community Apps', max_length=200, null=True, verbose_name='Theme'),
+        ),
+    ]

allianceauth/authentication/migrations/0023_alter_userprofile_language.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.13 on 2024-05-12 09:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0022_userprofile_theme'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='userprofile',
+            name='language',
+            field=models.CharField(blank=True, choices=[('en', 'English'), ('de', 'German'), ('es', 'Spanish'), ('zh-hans', 'Chinese Simplified'), ('ru', 'Russian'), ('ko', 'Korean'), ('fr', 'French'), ('ja', 'Japanese'), ('it', 'Italian'), ('uk', 'Ukrainian'), ('pl', 'Polish')], default='', max_length=10, verbose_name='Language'),
+        ),
+    ]

allianceauth/authentication/migrations/0024_alter_userprofile_language.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2 on 2024-09-13 09:46
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('authentication', '0023_alter_userprofile_language'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='userprofile',
+            name='language',
+            field=models.CharField(blank=True, choices=[('en', 'English'), ('cs-cz', 'Czech'), ('de', 'German'), ('es', 'Spanish'), ('it-it', 'Italian'), ('ja', 'Japanese'), ('ko-kr', 'Korean'), ('fr-fr', 'French'), ('ru', 'Russian'), ('nl-nl', 'Dutch'), ('pl-pl', 'Polish'), ('uk', 'Ukrainian'), ('zh-hans', 'Simplified Chinese')], default='', max_length=10, verbose_name='Language'),
+        ),
+    ]

allianceauth/authentication/migrations/0025_userprofile_minimize_sidebar.py

@@ -0,0 +1,22 @@
+# Generated by Django 4.2.25 on 2025-10-14 22:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("authentication", "0024_alter_userprofile_language"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="userprofile",
+            name="minimize_sidebar",
+            field=models.BooleanField(
+                default=False,
+                help_text="Keep the sidebar menu minimized",
+                verbose_name="Minimize Sidebar Menu",
+            ),
+        ),
+    ]

allianceauth/authentication/migrations/0025_v5squash.py

@@ -0,0 +1,124 @@
+# Generated by Django 5.1.6 on 2025-03-04 02:44
+
+import django.contrib.auth.models
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+import allianceauth.authentication.models
+
+
+def create_states(apps, schema_editor) -> None:
+    State = apps.get_model('authentication', 'State')
+
+    State.objects.update_or_create(name="Guest", defaults={'priority': 0, 'public': True})[0]
+    State.objects.update_or_create(name="Blue", defaults={'priority': 50, 'public': False})[0]
+    State.objects.update_or_create(name="Member", defaults={'priority': 100, 'public': False})[0]
+
+
+def create_states_reverse(apps, schema_editor) -> None:
+    pass
+
+
+class Migration(migrations.Migration):
+
+    replaces = [('authentication', '0001_initial'), ('authentication', '0002_auto_20160907_1914'), ('authentication', '0003_authservicesinfo_state'), ('authentication', '0004_create_permissions'), ('authentication', '0005_delete_perms'), ('authentication', '0006_auto_20160910_0542'), ('authentication', '0007_remove_authservicesinfo_is_blue'), ('authentication', '0008_set_state'), ('authentication', '0009_auto_20161021_0228'), ('authentication', '0010_only_one_authservicesinfo'), ('authentication', '0011_authservicesinfo_user_onetoonefield'), ('authentication', '0012_remove_add_delete_authservicesinfo_permissions'), ('authentication', '0013_service_modules'), ('authentication', '0014_fleetup_permission'), ('authentication', '0015_user_profiles'), ('authentication', '0016_ownershiprecord'), ('authentication', '0017_remove_fleetup_permission'), ('authentication', '0018_state_member_factions'), ('authentication', '0018_alter_state_name_length'), ('authentication', '0019_merge_20211026_0919'), ('authentication', '0020_userprofile_language_userprofile_night_mode'), ('authentication', '0021_alter_userprofile_language'), ('authentication', '0022_userprofile_theme'), ('authentication', '0023_alter_userprofile_language'), ('authentication', '0024_alter_userprofile_language')]
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('esi', '0012_fix_token_type_choices'),
+        ('eveonline', '0019_v5squash'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CharacterOwnership',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('owner_hash', models.CharField(max_length=28, unique=True)),
+                ('character', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='character_ownership', to='eveonline.evecharacter')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='character_ownerships', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'default_permissions': ('change', 'delete'),
+                'ordering': ['user', 'character__character_name'],
+            },
+        ),
+        migrations.CreateModel(
+            name='State',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=32, unique=True)),
+                ('priority', models.IntegerField(help_text='Users get assigned the state with the highest priority available to them.', unique=True)),
+                ('public', models.BooleanField(default=False, help_text='Make this state available to any character.')),
+                ('member_alliances', models.ManyToManyField(blank=True, help_text='Alliances to whose members this state is available.', to='eveonline.eveallianceinfo')),
+                ('member_characters', models.ManyToManyField(blank=True, help_text='Characters to which this state is available.', to='eveonline.evecharacter')),
+                ('member_corporations', models.ManyToManyField(blank=True, help_text='Corporations to whose members this state is available.', to='eveonline.evecorporationinfo')),
+                ('permissions', models.ManyToManyField(blank=True, to='auth.permission')),
+                ('member_factions', models.ManyToManyField(blank=True, help_text='Factions to whose members this state is available.', to='eveonline.evefactioninfo')),
+            ],
+            options={
+                'ordering': ['-priority'],
+            },
+        ),
+        migrations.CreateModel(
+            name='UserProfile',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('main_character', models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='eveonline.evecharacter')),
+                ('state', models.ForeignKey(default=allianceauth.authentication.models.get_guest_state_pk, on_delete=django.db.models.deletion.SET_DEFAULT, to='authentication.state')),
+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='profile', to=settings.AUTH_USER_MODEL)),
+                ('night_mode', models.BooleanField(blank=True, null=True, verbose_name='Night Mode')),
+                ('theme', models.CharField(blank=True, help_text='Bootstrap 5 Themes from https://bootswatch.com/ or Community Apps', max_length=200, null=True, verbose_name='Theme')),
+                ('language', models.CharField(blank=True, choices=[('en', 'English'), ('cs-cz', 'Czech'), ('de', 'German'), ('es', 'Spanish'), ('it-it', 'Italian'), ('ja', 'Japanese'), ('ko-kr', 'Korean'), ('fr-fr', 'French'), ('ru', 'Russian'), ('nl-nl', 'Dutch'), ('pl-pl', 'Polish'), ('uk', 'Ukrainian'), ('zh-hans', 'Simplified Chinese')], default='', max_length=10, verbose_name='Language')),
+            ],
+            options={
+                'default_permissions': ('change',),
+            },
+        ),
+        migrations.CreateModel(
+            name='Permission',
+            fields=[
+            ],
+            options={
+                'proxy': True,
+                'verbose_name': 'permission',
+                'verbose_name_plural': 'permissions',
+            },
+            bases=('auth.permission',),
+            managers=[
+                ('objects', django.contrib.auth.models.PermissionManager()),
+            ],
+        ),
+        migrations.CreateModel(
+            name='User',
+            fields=[
+            ],
+            options={
+                'proxy': True,
+                'verbose_name': 'user',
+                'verbose_name_plural': 'users',
+            },
+            bases=('auth.user',),
+            managers=[
+                ('objects', django.contrib.auth.models.UserManager()),
+            ],
+        ),
+        migrations.CreateModel(
+            name='OwnershipRecord',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('owner_hash', models.CharField(db_index=True, max_length=28)),
+                ('created', models.DateTimeField(auto_now=True)),
+                ('character', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ownership_records', to='eveonline.evecharacter')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ownership_records', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ['-created'],
+            },
+        ),
+        migrations.RunPython(create_states, create_states_reverse),
+
+    ]

allianceauth/authentication/models.py

@@ -1,9 +1,11 @@
 import logging
+from typing import ClassVar
 
-from django.contrib.auth.models import User, Permission
+from django.contrib.auth.models import Permission, User
 from django.db import models, transaction
-from django.utils.translation import ugettext_lazy as _
-from allianceauth.eveonline.models import EveCharacter, EveCorporationInfo, EveAllianceInfo, EveFactionInfo
+from django.utils.translation import gettext_lazy as _
+
+from allianceauth.eveonline.models import EveAllianceInfo, EveCharacter, EveCorporationInfo, EveFactionInfo
 from allianceauth.notifications import notify
 
 from .managers import CharacterOwnershipManager, StateManager
@@ -14,24 +16,30 @@ logger = logging.getLogger(__name__)
 class State(models.Model):
     name = models.CharField(max_length=32, unique=True)
     permissions = models.ManyToManyField(Permission, blank=True)
-    priority = models.IntegerField(unique=True, help_text="Users get assigned the state with the highest priority available to them.")
+    priority = models.IntegerField(
+        unique=True, help_text="Users get assigned the state with the highest priority available to them."
+    )
 
-    member_characters = models.ManyToManyField(EveCharacter, blank=True,
-                                               help_text="Characters to which this state is available.")
-    member_corporations = models.ManyToManyField(EveCorporationInfo, blank=True,
-                                                 help_text="Corporations to whose members this state is available.")
-    member_alliances = models.ManyToManyField(EveAllianceInfo, blank=True,
-                                              help_text="Alliances to whose members this state is available.")
-    member_factions = models.ManyToManyField(EveFactionInfo, blank=True,
-                                             help_text="Factions to whose members this state is available.")
+    member_characters = models.ManyToManyField(
+        EveCharacter, blank=True, help_text="Characters to which this state is available."
+    )
+    member_corporations = models.ManyToManyField(
+        EveCorporationInfo, blank=True, help_text="Corporations to whose members this state is available."
+    )
+    member_alliances = models.ManyToManyField(
+        EveAllianceInfo, blank=True, help_text="Alliances to whose members this state is available."
+    )
+    member_factions = models.ManyToManyField(
+        EveFactionInfo, blank=True, help_text="Factions to whose members this state is available."
+    )
     public = models.BooleanField(default=False, help_text="Make this state available to any character.")
 
-    objects = StateManager()
+    objects: ClassVar[StateManager] = StateManager()
 
     class Meta:
-        ordering = ['-priority']
+        ordering = ["-priority"]
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
     def available_to_character(self, character):
@@ -47,11 +55,11 @@ class State(models.Model):
         super().delete(**kwargs)
 
 
-def get_guest_state():
+def get_guest_state() -> State:
     try:
-        return State.objects.get(name='Guest')
+        return State.objects.get(name="Guest")
     except State.DoesNotExist:
-        return State.objects.create(name='Guest', priority=0, public=True)
+        return State.objects.create(name="Guest", priority=0, public=True)
 
 
 def get_guest_state_pk():
@@ -59,27 +67,81 @@ def get_guest_state_pk():
 
 
 class UserProfile(models.Model):
+    class Language(models.TextChoices):
+        """
+        Choices for UserProfile.language
+        """
+        # Sorted by Language Code alphabetical order + English at top
+        ENGLISH = 'en', _('English')
+        CZECH = 'cs-cz', _("Czech")  # Not yet at 50% translated
+        GERMAN = 'de', _('German')
+        SPANISH = 'es', _('Spanish')
+        ITALIAN = 'it-it', _('Italian')
+        JAPANESE = 'ja', _('Japanese')
+        KOREAN = 'ko-kr', _('Korean')
+        FRENCH = 'fr-fr', _('French')
+        RUSSIAN = 'ru', _('Russian')
+        DUTCH = 'nl-nl', _("Dutch")
+        POLISH = 'pl-pl', _("Polish")
+        UKRAINIAN = 'uk', _('Ukrainian')
+        CHINESE = 'zh-hans', _('Simplified Chinese')
+
+    user = models.OneToOneField(
+        User,
+        related_name='profile',
+        on_delete=models.CASCADE)
+    main_character = models.OneToOneField(
+        EveCharacter,
+        blank=True,
+        null=True,
+        on_delete=models.SET_NULL)
+    state = models.ForeignKey(
+        State,
+        on_delete=models.SET_DEFAULT,
+        default=get_guest_state_pk)
+    language = models.CharField(
+        _("Language"),
+        max_length=10,
+        choices=Language.choices,
+        blank=True,
+        default='')
+    night_mode = models.BooleanField(
+        _("Night Mode"),
+        blank=True,
+        null=True)
+    theme = models.CharField(
+        _("Theme"),
+        max_length=200,
+        blank=True,
+        null=True,
+        help_text="Bootstrap 5 Themes from https://bootswatch.com/ or Community Apps",
+    )
+    minimize_sidebar = models.BooleanField(
+        _("Minimize Sidebar Menu"),
+        default=False,
+        help_text=_("Keep the sidebar menu minimized")
+    )
+
+
     class Meta:
-        default_permissions = ('change',)
+        default_permissions = ("change",)
 
-    user = models.OneToOneField(User, related_name='profile', on_delete=models.CASCADE)
-    main_character = models.OneToOneField(EveCharacter, blank=True, null=True, on_delete=models.SET_NULL)
-    state = models.ForeignKey(State, on_delete=models.SET_DEFAULT, default=get_guest_state_pk)
+    def __str__(self) -> str:
+        return str(self.user)
 
-    def assign_state(self, state=None, commit=True):
+    def assign_state(self, state=None, commit=True) -> None:
         if not state:
             state = State.objects.get_for_user(self.user)
         if self.state != state:
             self.state = state
             if commit:
-                logger.info(f'Updating {self.user} state to {self.state}')
-                self.save(update_fields=['state'])
+                logger.info(f"Updating {self.user} state to {self.state}")
+                self.save(update_fields=["state"])
                 notify(
                     self.user,
-                    _('State changed to: %s' % state),
-                    _('Your user\'s state is now: %(state)s')
-                    % ({'state': state}),
-                    'info'
+                    _(f"State changed to: {state}"),
+                    _("Your user's state is now: %(state)s") % ({"state": state}),
+                    "info",
                 )
                 from allianceauth.authentication.signals import state_changed
 
@@ -87,37 +149,33 @@ class UserProfile(models.Model):
                 # Clear all attribute caches and reload the model that will get passed to the signals!
                 self.refresh_from_db()
 
-                state_changed.send(
-                    sender=self.__class__, user=self.user, state=self.state
-                )
-
-    def __str__(self):
-        return str(self.user)
+                state_changed.send(sender=self.__class__, user=self.user, state=self.state)
 
 
 class CharacterOwnership(models.Model):
+
+    character = models.OneToOneField(EveCharacter, on_delete=models.CASCADE, related_name='character_ownership')
+    owner_hash = models.CharField(max_length=28, unique=True)
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="character_ownerships")
+
+    objects: ClassVar[CharacterOwnershipManager] = CharacterOwnershipManager()
+
     class Meta:
         default_permissions = ('change', 'delete')
         ordering = ['user', 'character__character_name']
 
-    character = models.OneToOneField(EveCharacter, on_delete=models.CASCADE, related_name='character_ownership')
-    owner_hash = models.CharField(max_length=28, unique=True)
-    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='character_ownerships')
-
-    objects = CharacterOwnershipManager()
-
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.user}: {self.character}"
 
 
 class OwnershipRecord(models.Model):
-    character = models.ForeignKey(EveCharacter, on_delete=models.CASCADE, related_name='ownership_records')
+    character = models.ForeignKey(EveCharacter, on_delete=models.CASCADE, related_name="ownership_records")
     owner_hash = models.CharField(max_length=28, db_index=True)
-    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='ownership_records')
+    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="ownership_records")
     created = models.DateTimeField(auto_now=True)
 
     class Meta:
-        ordering = ['-created']
+        ordering = ["-created"]
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"{self.user}: {self.character} on {self.created}"

allianceauth/authentication/signals.py

@@ -1,17 +1,19 @@
 import logging
 
-from .models import CharacterOwnership, UserProfile, get_guest_state, State, OwnershipRecord
 from django.contrib.auth.models import User
 from django.db.models import Q
-from django.db.models.signals import pre_save, post_save, pre_delete, post_delete, m2m_changed
-from django.dispatch import receiver, Signal
+from django.db.models.signals import m2m_changed, post_delete, post_save, pre_delete, pre_save
+from django.dispatch import Signal, receiver
+
 from esi.models import Token
 
 from allianceauth.eveonline.models import EveCharacter
 
+from .models import CharacterOwnership, OwnershipRecord, State, UserProfile, get_guest_state
+
 logger = logging.getLogger(__name__)
 
-state_changed = Signal(providing_args=['user', 'state'])
+state_changed = Signal()
 
 
 def trigger_state_check(state):
@@ -71,7 +73,7 @@ def reassess_on_profile_save(sender, instance, created, *args, **kwargs):
 
 @receiver(post_save, sender=User)
 def create_required_models(sender, instance, created, *args, **kwargs):
-    # ensure all users have a model
+    # ensure all users have our Sub-Models
     if created:
         logger.debug(f'User {instance} created. Creating default UserProfile.')
         UserProfile.objects.get_or_create(user=instance)
@@ -103,8 +105,7 @@ def record_character_ownership(sender, instance, created, *args, **kwargs):
 def validate_main_character(sender, instance, *args, **kwargs):
     try:
         if instance.user.profile.main_character == instance.character:
-            logger.info("Ownership of a main character {} has been revoked. Resetting {} main character.".format(
-                instance.character, instance.user))
+            logger.info(f"Ownership of a main character {instance.character} has been revoked. Resetting {instance.user} main character.")
             # clear main character as user no longer owns them
             instance.user.profile.main_character = None
             instance.user.profile.save()

allianceauth/authentication/static/allianceauth/authentication/css/admin.css

@@ -0,0 +1,31 @@
+/*
+CSS for allianceauth admin site
+*/
+
+/* styling for profile pic */
+.img-circle {
+    border-radius: 50%;
+}
+
+.column-user_profile_pic {
+    white-space: nowrap;
+    width: 1px;
+}
+
+/* tooltip */
+.tooltip {
+    position: relative;
+}
+
+.tooltip:hover::after {
+    background-color: rgb(255 255 204);
+    border: 1px rgb(128 128 128) solid;
+    color: rgb(0 0 0);
+    content: attr(data-tooltip);
+    left: 1em;
+    min-width: 200px;
+    padding: 8px;
+    position: absolute;
+    top: 1.1em;
+    z-index: 1;
+}

allianceauth/authentication/static/authentication/css/admin.css

@@ -1,29 +0,0 @@
-/*
-CSS for allianceauth admin site
-*/
-
-/* styling for profile pic */
-.img-circle {
-    border-radius: 50%;
-}
-.column-user_profile_pic {
-    width: 1px;
-    white-space: nowrap;
-}
-
-/* tooltip */
-.tooltip {
-    position: relative ;
-}
-.tooltip:hover::after {
-    content: attr(data-tooltip) ;
-    position: absolute ;
-    top: 1.1em ;
-    left: 1em ;
-    min-width: 200px ;
-    border: 1px #808080 solid ;
-    padding: 8px ;
-    color: black ;
-    background-color: rgb(255, 255, 204) ;
-    z-index: 1 ;
-}

allianceauth/authentication/task_statistics/counters.py

@@ -1,29 +1,34 @@
-from collections import namedtuple
+"""Counters for Task Statistics."""
+
 import datetime as dt
+from typing import NamedTuple
 
 from .event_series import EventSeries
 
-
-"""Global series for counting task events."""
+# Global series for counting task events.
 succeeded_tasks = EventSeries("SUCCEEDED_TASKS")
 retried_tasks = EventSeries("RETRIED_TASKS")
 failed_tasks = EventSeries("FAILED_TASKS")
 
 
-_TaskCounts = namedtuple(
-    "_TaskCounts", ["succeeded", "retried", "failed", "total", "earliest_task", "hours"]
-)
+class _TaskCounts(NamedTuple):
+    succeeded: int
+    retried: int
+    failed: int
+    total: int
+    earliest_task: dt.datetime | None
+    hours: int
 
 
 def dashboard_results(hours: int) -> _TaskCounts:
-    """Counts of all task events within the given timeframe."""
+    """Counts of all task events within the given time frame."""
 
     def earliest_if_exists(events: EventSeries, earliest: dt.datetime) -> list:
         my_earliest = events.first_event(earliest=earliest)
         return [my_earliest] if my_earliest else []
 
-    earliest = dt.datetime.utcnow() - dt.timedelta(hours=hours)
-    earliest_events = list()
+    earliest = dt.datetime.now(dt.timezone.utc) - dt.timedelta(hours=hours)
+    earliest_events = []
     succeeded_count = succeeded_tasks.count(earliest=earliest)
     earliest_events += earliest_if_exists(succeeded_tasks, earliest)
     retried_count = retried_tasks.count(earliest=earliest)

allianceauth/authentication/task_statistics/event_series.py

@@ -1,61 +1,30 @@
+"""Event series for Task Statistics."""
+
 import datetime as dt
 import logging
-from typing import List, Optional
 
 from pytz import utc
-from redis import Redis, RedisError
+from redis import Redis
 
-from django.core.cache import cache
+from .helpers import get_redis_client_or_stub
 
 logger = logging.getLogger(__name__)
 
 
-class _RedisStub:
-    """Stub of a Redis client.
-
-    It's purpose is to prevent EventSeries objects from trying to access Redis
-    when it is not available. e.g. when the Sphinx docs are rendered by readthedocs.org.
-    """
-
-    def delete(self, *args, **kwargs):
-        pass
-
-    def incr(self, *args, **kwargs):
-        return 0
-
-    def zadd(self, *args, **kwargs):
-        pass
-
-    def zcount(self, *args, **kwargs):
-        pass
-
-    def zrangebyscore(self, *args, **kwargs):
-        pass
-
-
 class EventSeries:
     """API for recording and analyzing a series of events."""
 
     _ROOT_KEY = "ALLIANCEAUTH_EVENT_SERIES"
 
-    def __init__(self, key_id: str, redis: Redis = None) -> None:
-        self._redis = cache.get_master_client() if not redis else redis
-        try:
-            if not self._redis.ping():
-                raise RuntimeError()
-        except (AttributeError, RedisError, RuntimeError):
-            logger.exception(
-                "Failed to establish a connection with Redis. "
-                "This EventSeries object is disabled.",
-            )
-            self._redis = _RedisStub()
+    def __init__(self, key_id: str, redis: Redis | None = None) -> None:
+        self._redis = get_redis_client_or_stub() if not redis else redis
         self._key_id = str(key_id)
         self.clear()
 
     @property
     def is_disabled(self):
         """True when this object is disabled, e.g. Redis was not available at startup."""
-        return isinstance(self._redis, _RedisStub)
+        return hasattr(self._redis, "IS_STUB")
 
     @property
     def _key_counter(self):
@@ -72,11 +41,11 @@ class EventSeries:
         - event_time: timestamp of event. Will use current time if not specified.
         """
         if not event_time:
-            event_time = dt.datetime.utcnow()
-        id = self._redis.incr(self._key_counter)
-        self._redis.zadd(self._key_sorted_set, {id: event_time.timestamp()})
+            event_time = dt.datetime.now(dt.timezone.utc)
+        my_id = self._redis.incr(self._key_counter)
+        self._redis.zadd(self._key_sorted_set, {my_id: event_time.timestamp()})
 
-    def all(self) -> List[dt.datetime]:
+    def all(self) -> list[dt.datetime]:
         """List of all known events."""
         return [
             event[1]
@@ -95,26 +64,26 @@ class EventSeries:
         self._redis.delete(self._key_counter)
 
     def count(self, earliest: dt.datetime = None, latest: dt.datetime = None) -> int:
-        """Count of events, can be restricted to given timeframe.
+        """Count of events, can be restricted to given time frame.
 
         Args:
         - earliest: Date of first events to count(inclusive), or -infinite if not specified
         - latest: Date of last events to count(inclusive), or +infinite if not specified
         """
-        min = "-inf" if not earliest else earliest.timestamp()
-        max = "+inf" if not latest else latest.timestamp()
-        return self._redis.zcount(self._key_sorted_set, min=min, max=max)
+        minimum = "-inf" if not earliest else earliest.timestamp()
+        maximum = "+inf" if not latest else latest.timestamp()
+        return self._redis.zcount(self._key_sorted_set, min=minimum, max=maximum)
 
-    def first_event(self, earliest: dt.datetime = None) -> Optional[dt.datetime]:
+    def first_event(self, earliest: dt.datetime = None) -> dt.datetime | None:
         """Date/Time of first event. Returns `None` if series has no events.
 
         Args:
         - earliest: Date of first events to count(inclusive), or any if not specified
         """
-        min = "-inf" if not earliest else earliest.timestamp()
+        minimum = "-inf" if not earliest else earliest.timestamp()
         event = self._redis.zrangebyscore(
             self._key_sorted_set,
-            min,
+            minimum,
             "+inf",
             withscores=True,
             start=0,

allianceauth/authentication/task_statistics/helpers.py

@@ -0,0 +1,49 @@
+"""Helpers for Task Statistics."""
+
+import logging
+
+from redis import Redis, RedisError
+
+from allianceauth.utils.cache import get_redis_client
+
+logger = logging.getLogger(__name__)
+
+
+class _RedisStub:
+    """Stub of a Redis client.
+
+    It's purpose is to prevent EventSeries objects from trying to access Redis
+    when it is not available. e.g. when the Sphinx docs are rendered by readthedocs.org.
+    """
+
+    IS_STUB = True
+
+    def delete(self, *args, **kwargs):
+        pass
+
+    def incr(self, *args, **kwargs):
+        return 0
+
+    def zadd(self, *args, **kwargs):
+        pass
+
+    def zcount(self, *args, **kwargs):
+        pass
+
+    def zrangebyscore(self, *args, **kwargs):
+        pass
+
+
+def get_redis_client_or_stub() -> Redis:
+    """Return AA's default cache client or a stub if Redis is not available."""
+    redis = get_redis_client()
+    try:
+        if not redis.ping():
+            raise RuntimeError()
+    except (AttributeError, RedisError, RuntimeError):
+        logger.exception(
+            "Failed to establish a connection with Redis. "
+            "This EventSeries object is disabled.",
+        )
+        return _RedisStub()
+    return redis

allianceauth/authentication/task_statistics/signals.py

@@ -1,9 +1,11 @@
+"""Signals for Task Statistics."""
+
 from celery.signals import (
     task_failure,
     task_internal_error,
     task_retry,
     task_success,
-    worker_ready
+    worker_ready,
 )
 
 from django.conf import settings
@@ -19,6 +21,7 @@ def reset_counters():
 
 
 def is_enabled() -> bool:
+    """Return True if task statistics are enabled, else return False."""
     return not bool(
         getattr(settings, "ALLIANCEAUTH_DASHBOARD_TASK_STATISTICS_DISABLED", False)
     )

allianceauth/authentication/task_statistics/tests/test_counters.py

@@ -5,28 +5,32 @@ from django.utils.timezone import now
 
 from allianceauth.authentication.task_statistics.counters import (
     dashboard_results,
-    succeeded_tasks,
-    retried_tasks,
     failed_tasks,
+    retried_tasks,
+    succeeded_tasks,
 )
 
 
 class TestDashboardResults(TestCase):
-    def test_should_return_counts_for_given_timeframe_only(self):
+    def test_should_return_counts_for_given_time_frame_only(self):
         # given
         earliest_task = now() - dt.timedelta(minutes=15)
+
         succeeded_tasks.clear()
         succeeded_tasks.add(now() - dt.timedelta(hours=1, seconds=1))
         succeeded_tasks.add(earliest_task)
         succeeded_tasks.add()
         succeeded_tasks.add()
+
         retried_tasks.clear()
         retried_tasks.add(now() - dt.timedelta(hours=1, seconds=1))
         retried_tasks.add(now() - dt.timedelta(seconds=30))
         retried_tasks.add()
+
         failed_tasks.clear()
         failed_tasks.add(now() - dt.timedelta(hours=1, seconds=1))
         failed_tasks.add()
+
         # when
         results = dashboard_results(hours=1)
         # then

allianceauth/authentication/task_statistics/tests/test_event_series.py

@@ -1,48 +1,19 @@
 import datetime as dt
-from unittest.mock import patch
 
 from pytz import utc
-from redis import RedisError
 
 from django.test import TestCase
 from django.utils.timezone import now
 
 from allianceauth.authentication.task_statistics.event_series import (
     EventSeries,
-    _RedisStub,
 )
+from allianceauth.authentication.task_statistics.helpers import _RedisStub
 
 MODULE_PATH = "allianceauth.authentication.task_statistics.event_series"
 
 
 class TestEventSeries(TestCase):
-    def test_should_abort_without_redis_client(self):
-        # when
-        with patch(MODULE_PATH + ".cache.get_master_client") as mock:
-            mock.return_value = None
-            events = EventSeries("dummy")
-        # then
-        self.assertTrue(events._redis, _RedisStub)
-        self.assertTrue(events.is_disabled)
-
-    def test_should_disable_itself_if_redis_not_available_1(self):
-        # when
-        with patch(MODULE_PATH + ".cache.get_master_client") as mock_get_master_client:
-            mock_get_master_client.return_value.ping.side_effect = RedisError
-            events = EventSeries("dummy")
-        # then
-        self.assertIsInstance(events._redis, _RedisStub)
-        self.assertTrue(events.is_disabled)
-
-    def test_should_disable_itself_if_redis_not_available_2(self):
-        # when
-        with patch(MODULE_PATH + ".cache.get_master_client") as mock_get_master_client:
-            mock_get_master_client.return_value.ping.return_value = False
-            events = EventSeries("dummy")
-        # then
-        self.assertIsInstance(events._redis, _RedisStub)
-        self.assertTrue(events.is_disabled)
-
     def test_should_add_event(self):
         # given
         events = EventSeries("dummy")
@@ -166,3 +137,15 @@ class TestEventSeries(TestCase):
         results = events.all()
         # then
         self.assertEqual(len(results), 2)
+
+    def test_should_not_report_as_disabled_when_initialized_normally(self):
+        # given
+        events = EventSeries("dummy")
+        # when/then
+        self.assertFalse(events.is_disabled)
+
+    def test_should_report_as_disabled_when_initialized_with_redis_stub(self):
+        # given
+        events = EventSeries("dummy", redis=_RedisStub())
+        # when/then
+        self.assertTrue(events.is_disabled)

allianceauth/authentication/task_statistics/tests/test_helpers.py

@@ -0,0 +1,29 @@
+from unittest import TestCase
+from unittest.mock import patch
+
+from redis import RedisError
+
+from allianceauth.authentication.task_statistics.helpers import (
+    _RedisStub,
+    get_redis_client_or_stub,
+)
+
+MODULE_PATH = "allianceauth.authentication.task_statistics.helpers"
+
+
+class TestGetRedisClient(TestCase):
+    def test_should_return_mock_if_redis_not_available_1(self):
+        # when
+        with patch(MODULE_PATH + ".get_redis_client") as mock_get_master_client:
+            mock_get_master_client.return_value.ping.side_effect = RedisError
+            result = get_redis_client_or_stub()
+        # then
+        self.assertIsInstance(result, _RedisStub)
+
+    def test_should_return_mock_if_redis_not_available_2(self):
+        # when
+        with patch(MODULE_PATH + ".get_redis_client") as mock_get_master_client:
+            mock_get_master_client.return_value.ping.return_value = False
+            result = get_redis_client_or_stub()
+        # then
+        self.assertIsInstance(result, _RedisStub)

allianceauth/authentication/task_statistics/tests/test_signals.py

@@ -10,23 +10,24 @@ from allianceauth.authentication.task_statistics.counters import (
     succeeded_tasks,
 )
 from allianceauth.authentication.task_statistics.signals import (
-    reset_counters,
     is_enabled,
+    reset_counters,
 )
 from allianceauth.eveonline.tasks import update_character
 
 
 @override_settings(
-    CELERY_ALWAYS_EAGER=True,ALLIANCEAUTH_DASHBOARD_TASK_STATISTICS_DISABLED=False
+    CELERY_ALWAYS_EAGER=True, ALLIANCEAUTH_DASHBOARD_TASK_STATISTICS_DISABLED=False
 )
 class TestTaskSignals(TestCase):
     fixtures = ["disable_analytics"]
 
-    def test_should_record_successful_task(self):
-        # given
+    def setUp(self) -> None:
         succeeded_tasks.clear()
         retried_tasks.clear()
         failed_tasks.clear()
+
+    def test_should_record_successful_task(self):
         # when
         with patch(
             "allianceauth.eveonline.tasks.EveCharacter.objects.update_character"
@@ -39,10 +40,6 @@ class TestTaskSignals(TestCase):
         self.assertEqual(failed_tasks.count(), 0)
 
     def test_should_record_retried_task(self):
-        # given
-        succeeded_tasks.clear()
-        retried_tasks.clear()
-        failed_tasks.clear()
         # when
         with patch(
             "allianceauth.eveonline.tasks.EveCharacter.objects.update_character"
@@ -55,10 +52,6 @@ class TestTaskSignals(TestCase):
         self.assertEqual(retried_tasks.count(), 1)
 
     def test_should_record_failed_task(self):
-        # given
-        succeeded_tasks.clear()
-        retried_tasks.clear()
-        failed_tasks.clear()
         # when
         with patch(
             "allianceauth.eveonline.tasks.EveCharacter.objects.update_character"

allianceauth/authentication/tasks.py

@@ -1,9 +1,10 @@
 import logging
 
-from esi.errors import TokenExpiredError, TokenInvalidError, IncompleteResponseError
-from esi.models import Token
 from celery import shared_task
 
+from esi.errors import IncompleteResponseError, TokenExpiredError, TokenInvalidError
+from esi.models import Token
+
 from allianceauth.authentication.models import CharacterOwnership
 
 logger = logging.getLogger(__name__)
@@ -22,8 +23,7 @@ def check_character_ownership(owner_hash):
                 continue
             except (KeyError, IncompleteResponseError):
                 # We can't validate the hash hasn't changed but also can't assume it has. Abort for now.
-                logger.warning("Failed to validate owner hash of {} due to problems contacting SSO servers.".format(
-                    tokens[0].character_name))
+                logger.warning(f"Failed to validate owner hash of {tokens[0].character_name} due to problems contacting SSO servers.")
                 break
 
             if not t.character_owner_hash == old_hash:
@@ -33,7 +33,7 @@ def check_character_ownership(owner_hash):
             break
 
     if not Token.objects.filter(character_owner_hash=owner_hash).exists():
-        logger.info('No tokens found with owner hash %s. Revoking ownership.' % owner_hash)
+        logger.info(f'No tokens found with owner hash {owner_hash}. Revoking ownership.')
         CharacterOwnership.objects.filter(owner_hash=owner_hash).delete()