Merge pull request 'Master' (#548) from master into Docker

Reviewed-on: #548

Dockerfile

@@ -0,0 +1,36 @@
+# Nutze ein schlankes Python-Image
+FROM python:3.13-slim-bullseye
+
+ENV PYTHONUNBUFFERED 1
+
+WORKDIR /konova
+
+# Installiere System-Abhängigkeiten
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gdal-bin redis-server nginx \
+    && rm -rf /var/lib/apt/lists/*  # Platz sparen
+
+# Erstelle benötigte Verzeichnisse & setze Berechtigungen
+RUN mkdir -p /var/log/nginx /var/log/gunicorn /var/lib/nginx /tmp/nginx_client_body \
+    && touch /var/log/nginx/access.log /var/log/nginx/error.log \
+    && chown -R root:root /var/log/nginx /var/lib/nginx /tmp/nginx_client_body
+
+# Kopiere und installiere Python-Abhängigkeiten
+COPY ./requirements.txt /konova/
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+# Entferne Standard-Nginx-Site und ersetze sie durch eigene Config
+RUN rm -rf /etc/nginx/sites-enabled/default
+COPY ./nginx.conf /etc/nginx/conf.d
+
+# Kopiere restliche Projektdateien
+COPY . /konova/
+
+# Sammle statische Dateien
+RUN python manage.py collectstatic --noinput
+
+# Exponiere Ports
+#EXPOSE 80 6379 8000
+
+# Setze Entrypoint
+ENTRYPOINT ["/konova/docker-entrypoint.sh"]

README.md

@@ -4,6 +4,7 @@ the database postgresql and the css library bootstrap as well as the icon packag
 fontawesome for a modern look, following best practices from the industry.
 
 ## Background processes
+### !!! For non-docker run
 Konova uses celery for background processing. To start the worker you need to run
 ```shell
 $ celery -A konova worker -l INFO
@@ -18,3 +19,58 @@ Technical documention is provided in the projects git wiki.
 A user documentation is not available (and not needed, yet). 
 
 
+# Docker 
+To run the docker-compose as expected, you need to take the following steps:
+
+1. Create a database containing docker, using an appropriate Dockerfile, e.g. the following
+```
+version: '3.3'
+services:
+  postgis:
+    image: postgis/postgis
+    restart: always
+    container_name: postgis-docker
+    ports: 
+      - 5433:5432
+    volumes:
+      - db-volume:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_USER=postgres
+    networks:
+      - db-network-bridge
+
+networks:
+  db-network-bridge:
+    driver: "bridge"
+
+volumes:
+  db-volume:
+```
+This Dockerfile creates a Docker container running postgresql and postgis, creates the default superuser postgres, 
+creates a named volume for persisting the database and creates a new network bridge, which **must be used by any other
+container, which wants to write/read on this database**. 
+
+2. Make sure the name of the network bridge above matches the network in the konova docker-compose.yml  
+3. Get into the running postgis container (`docker exec -it postgis-docker bash`) and create new databases, users and so on. Make sure the database `konova` exists now!
+4. Replace all `CHANGE_ME_xy` values inside of konova/docker-compose.yml for your installation. Make sure the `SSO_HOST` holds the proper SSO host, e.g. for the arnova project `arnova.example.org` (Arnova must be installed and the webserver configured as well, of course)
+5. Take a look on konova/settings.py and konova/sub_settings/django_settings.py. Again: Replace all occurences of `CHANGE_ME` with proper values for your installation.
+   1. Make sure you have the proper host strings added to `ALLOWED_HOSTS` inside of django_settings.py.  
+6. Build and run the docker setup using `docker-compose build` and `docker-compose start` from the main directory of this project (where the docker-compose.yml lives)
+7. Run migrations! To do so, get into the konova service container (`docker exec -it konova-docker bash`) and run the needed commands (`python manage.py makemigrations LIST_OF_ALL_MIGRATABLE_APPS`, then `python manage.py migrate`)
+8. Run the setup command `python manage.py setup` and follow the instructions on the CLI
+9. To enable **SMTP** mail support, make sure your host machine (the one where the docker container run) has the postfix service configured properly. Make sure the `mynetworks` variable is xtended using the docker network bridge ip, created in the postgis container and used by the konova services.
+   1. **Hint**: You can find out this easily by trying to perform a test mail in the running konova web application (which will fail, of course). Then take a look to the latest entries in `/var/log/mail.log` on your host machine. The failed IP will be displayed there.
+   2. **Please note**: This installation guide is based on SMTP using postfix! 
+   3. Restart the postfix service on your host machine to reload the new configuration (`service postfix restart`)
+10. Finally, make sure your host machine webserver passes incoming requests properly to the docker nginx webserver of konova. A proper nginx config for the host machine may look like this:
+```
+server {
+    server_name konova.domain.org;
+
+    location / {
+        proxy_pass http://localhost:KONOVA_NGINX_DOCKER_PORT/;
+        proxy_set_header Host $host;
+    }
+}
+```

api/utils/serializer/serializer.py

@@ -6,7 +6,6 @@ Created on: 24.01.22
 
 """
 import json
-import uuid
 from abc import abstractmethod
 
 from django.contrib.gis import geos
@@ -156,11 +155,6 @@ class AbstractModelAPISerializer:
         if isinstance(geojson, dict):
             geojson = json.dumps(geojson)
         geometry = geos.fromstr(geojson)
-        if not geometry.valid:
-            raise ValueError(f"Invalid geometry: {geometry.valid_reason}")
-        is_4326 = Geometry.is_valid_4326(geometry)
-        if not is_4326:
-            raise ValueError("Geometry not in EPSG:4326 (WGS84). Unknown spatial reference system.")
         geometry = Geometry.cast_to_rlp_srid(geometry)
         geometry = Geometry.cast_to_multipolygon(geometry)
         return geometry
@@ -177,20 +171,13 @@ class AbstractModelAPISerializer:
         Returns:
 
         """
-        if not id:
-            raise ValueError("No id provided. The id is expected to live in the URL!")
-
         # First if there is an external identifier linked to an internal one, so we can continue with the internal
         try:
             ext_id = ExternalIdentifier.objects.get(external_id=id)
             id = ext_id.internal_id
         except ObjectDoesNotExist:
-            # Not found as external id - let's check whether this is a valid uuid and therefore
-            # potentially an internal id
-            try:
-                uuid.UUID(id)
-            except ValueError:
-                raise AssertionError(f"'{id}' is neither a known external identifier nor a valid uuid.")
+            # No external id found - let's hope the given id exists internally
+            pass
 
         obj = self.model.objects.get(
             id=id,
@@ -230,11 +217,7 @@ class AbstractModelAPISerializer:
         conflict_geometries = geometry.get_conflict_geometries()
         for geom in conflict_geometries:
             try:
-                data = geom.get_data_objects(["identifier", "id"])
-                if len(data) == 0:
-                    # expected behaviour in case of deleted data object
-                    continue
-                data = data[0]
+                data = geom.get_data_objects(["identifier", "id"])[0]
             except KeyError:
                 raise AssertionError(f"Geometry {geom.id} is not attached to any entries. Contact an admin!")
             ids.append(

api/views/v1/views.py

@@ -10,7 +10,6 @@ from json import JSONDecodeError
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import JsonResponse, HttpRequest
-from django.views.decorators.csrf import csrf_exempt
 
 from api.utils.serializer.v1.compensation import CompensationAPISerializerV1
 from api.utils.serializer.v1.deduction import DeductionAPISerializerV1
@@ -29,20 +28,6 @@ class AbstractAPIViewV1(AbstractAPIView):
         super().__init__(*args, **kwargs)
         self.serializer = self.serializer()
 
-    @csrf_exempt
-    def dispatch(self, request, *args, **kwargs):
-        try:
-            return super().dispatch(request, *args, **kwargs)
-        except (JSONDecodeError,
-                AssertionError,
-                ValueError,
-                PermissionError) as e:
-            return self._return_error_response(e, 400)
-        except ObjectDoesNotExist as e:
-            return self._return_error_response(e, 404)
-        except Exception as e:
-            return self._return_error_response(e, 500)
-
     def get(self, request: HttpRequest, id=None):
         """ Handles the GET request
 
@@ -55,12 +40,17 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        self.rpp = int(request.GET.get("rpp", self.rpp))
-        self.page_number = int(request.GET.get("p", self.page_number))
-        self.serializer.rpp = self.rpp
-        self.serializer.page_number = self.page_number
-        self.serializer.prepare_lookup(id, self.user)
-        data = self.serializer.fetch_and_serialize()
+        try:
+            self.rpp = int(request.GET.get("rpp", self.rpp))
+            self.page_number = int(request.GET.get("p", self.page_number))
+
+            self.serializer.rpp = self.rpp
+            self.serializer.page_number = self.page_number
+
+            self.serializer.prepare_lookup(id, self.user)
+            data = self.serializer.fetch_and_serialize()
+        except Exception as e:
+            return self._return_error_response(e, 500)
         return self._return_response(request, data)
 
     def post(self, request: HttpRequest):
@@ -74,9 +64,16 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        body = request.body.decode("utf-8")
-        body = json.loads(body)
-        created_id = self.serializer.create_model_from_json(body, self.user)
+        try:
+            body = request.body.decode("utf-8")
+            body = json.loads(body)
+            created_id = self.serializer.create_model_from_json(body, self.user)
+        except (JSONDecodeError,
+                AssertionError,
+                ValueError,
+                PermissionError,
+                ObjectDoesNotExist) as e:
+            return self._return_error_response(e, 400)
         return JsonResponse({"id": created_id})
 
     def put(self, request: HttpRequest, id=None):
@@ -91,9 +88,12 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        body = request.body.decode("utf-8")
-        body = json.loads(body)
-        updated_id = self.serializer.update_model_from_json(id, body, self.user)
+        try:
+            body = request.body.decode("utf-8")
+            body = json.loads(body)
+            updated_id = self.serializer.update_model_from_json(id, body, self.user)
+        except Exception as e:
+            return self._return_error_response(e, 500)
         return JsonResponse({"id": updated_id})
 
     def delete(self, request: HttpRequest, id=None):
@@ -107,7 +107,10 @@ class AbstractAPIViewV1(AbstractAPIView):
             response (JsonResponse)
         """
 
-        success = self.serializer.delete_entry(id, self.user)
+        try:
+            success = self.serializer.delete_entry(id, self.user)
+        except Exception as e:
+            return self._return_error_response(e, 500)
         return JsonResponse(
             {
                 "success": success,

compensation/models/compensation.py

@@ -325,8 +325,8 @@ class Compensation(AbstractCompensation, CEFMixin, CoherenceMixin, PikMixin):
             self.identifier = self.generate_new_identifier()
         super().save(*args, **kwargs)
 
-    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
-        super().mark_as_deleted(user, send_mail, comment)
+    def mark_as_deleted(self, user, send_mail: bool = True):
+        super().mark_as_deleted(user, send_mail)
         if user is not None:
             self.intervention.mark_as_edited(user, edit_comment=COMPENSATION_REMOVED_TEMPLATE.format(self.identifier))
 

docker-compose.yml

@@ -0,0 +1,21 @@
+services:
+  konova:
+    external_links:
+      - postgis:db
+      - arnova-nginx-server:arnova
+    build: .
+    image: "ksp/konova:x.y"
+    container_name: "konova-docker"
+    command: ./docker-entrypoint.sh
+    restart: always
+    volumes:
+      - /data/apps/konova/uploaded_files:/konova_uploaded_files
+    ports:
+      - "1337:80"
+
+# Instead of an own, new network, we need to connect to the existing one, which is provided by the postgis container
+# NOTE: THIS NETWORK MUST EXIST
+networks:
+  default:
+    name: postgis_nat_it_backend
+    external: true

docker-entrypoint.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -e  # Beende Skript bei Fehlern
+set -o pipefail  # Fehler in Pipelines nicht ignorieren
+
+# Starte Redis
+redis-server --daemonize yes
+
+# Starte Celery Worker im Hintergrund
+celery -A konova worker --loglevel=info &
+
+# Starte Nginx als Hintergrundprozess
+nginx -g "daemon off;" &
+
+# Setze Gunicorn Worker-Anzahl (Standard: (2*CPUs)+1)
+WORKERS=${GUNICORN_WORKERS:-$((2 * $(nproc) + 1))}
+
+# Stelle sicher, dass Logs existieren
+mkdir -p /var/log/gunicorn
+touch /var/log/gunicorn/access.log /var/log/gunicorn/error.log
+
+# Starte Gunicorn als Hauptprozess
+exec gunicorn --workers="$WORKERS" konova.wsgi:application \
+    --bind=0.0.0.0:8000 \
+    --access-logfile /var/log/gunicorn/access.log \
+    --error-logfile /var/log/gunicorn/error.log \
+    --access-logformat '%({x-real-ip}i)s via %(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'

intervention/models/intervention.py

@@ -306,7 +306,7 @@ class Intervention(BaseObject,
             self.set_unchecked()
         return action
 
-    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
+    def mark_as_deleted(self, user, send_mail: bool = True):
         """ Extends base mark_as_delete functionality
 
         Removes related deductions from the database, which results in updating the deductable_rest of the
@@ -315,12 +315,11 @@ class Intervention(BaseObject,
         Args:
             user (User): The performing user
             send_mail (bool): Whether to send an info mail
-            comment (str|None): The delete comment
 
         Returns:
 
         """
-        super().mark_as_deleted(user, send_mail, comment)
+        super().mark_as_deleted(user, send_mail)
 
         # Remove pending deductions to free booked capacities
         deductions = self.deductions.all()

konova/management/commands/mass_delete_entries.py

@@ -1,113 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 16.07.26
-
-"""
-from django.db.models import QuerySet
-
-from compensation.models import Compensation, EcoAccount
-from ema.models import Ema
-from intervention.models import Intervention
-from konova.management.commands.setup import BaseKonovaCommand
-from user.models import User
-
-
-class Command(BaseKonovaCommand):
-    help = "Mass-deletes entries according to user input"
-
-    _DELETE_CLS = None
-    _DELETE_COMMENT = None
-    _DELETE_IDENTIFIER_ILIKE_PARAM = None
-    _DELETE_USER = None
-
-    def handle(self, *args, **options):
-        self._get_delete_user()
-        self._get_object_type()
-        self._get_identifier_ilike_param()
-        self._get_delete_comment()
-        self._show_config()
-        entries = self._collect_entries()
-        self._process_delete(entries)
-
-    def _get_delete_user(self):
-        self._DELETE_USER = User.objects.filter(
-            is_superuser=True,
-            is_staff=True
-        ).order_by(
-            "id"
-        ).first()
-
-        if not self._DELETE_USER:
-            self._write_error("No admin-staff user could be found. Please check the admin users!")
-
-    def _get_object_type(self):
-        object_types = {
-            "eiv": Intervention,
-            "kom": Compensation,
-            "oek": EcoAccount,
-            "ema": Ema,
-        }
-        object_types_str = "|".join(object_types.keys())
-        object_type_select = input(f"Which object type shall be processed? ({object_types_str}): ").lower()
-        try:
-            self._DELETE_CLS = object_types[object_type_select]
-            if self._DELETE_CLS == EcoAccount:
-                oek_deduction_remove_understood = input(f"Please be aware that deleting OEKs will result in TOTAL REMOVING of their deductions without any chance to restore them. Do you want to continue? (y|n): ")
-                oek_deduction_remove_understood = oek_deduction_remove_understood.lower() == "y"
-                if not oek_deduction_remove_understood:
-                    self._write_error("Removing of OEK canceled. Abort.")
-                    exit(-1)
-
-        except KeyError:
-            self._write_error(f"'{object_type_select}' not a valid option of {object_types_str}. Abort.")
-            exit(-1)
-
-    def _get_identifier_ilike_param(self):
-        self._DELETE_IDENTIFIER_ILIKE_PARAM = input("Use this substring to search in identifiers: ")
-
-    def _get_delete_comment(self):
-        self._DELETE_COMMENT = input("Comment to store in delete action: ")
-
-    def _show_config(self):
-        assert self._DELETE_CLS is not None
-        assert self._DELETE_IDENTIFIER_ILIKE_PARAM is not None
-        assert self._DELETE_COMMENT is not None
-
-        self._write_warning("You are about to delete entries with:")
-        self._write_warning(f"    Object type: {self._DELETE_CLS.__name__}")
-        self._write_warning(f"    Identifier pattern: '*{self._DELETE_IDENTIFIER_ILIKE_PARAM}*'")
-        self._write_warning(f"    Comment for delete action: '{self._DELETE_COMMENT}'")
-        self._write_warning(f"    Delete performing user: '{self._DELETE_USER}'")
-
-    def _collect_entries(self):
-        return self._DELETE_CLS.objects.filter(
-            deleted__isnull=True,
-            identifier__contains=self._DELETE_IDENTIFIER_ILIKE_PARAM
-        )
-
-    def _process_delete(self, entries: QuerySet):
-        entries_count = entries.count()
-        if entries_count == 0:
-            self._write_success(f"Found {entries_count} matches to delete. Nothing to do here. Bye.")
-            exit(0)
-
-        self._write_warning(f"Found {entries_count} matches to delete. Please double-check whether these samples from the results are what you expected: ")
-        first_three_elements = entries[:3]
-        for element in first_three_elements:
-            self._write_warning(f"    {element.identifier} ({element.id})")
-
-        delete_input = input("Are you ready to delete them now? (y|n): ").lower()
-        delete_now = delete_input == "y"
-        if not delete_now:
-            self._write_error(f"Entered unknown '{delete_input}'. Abort.")
-            exit(-1)
-        else:
-            i = 0
-            for element in entries:
-                if i % 10 == 0:
-                    self._write_warning(f"    Deleted {i}/{entries_count}")
-                element.mark_as_deleted(user=self._DELETE_USER, send_mail=False, comment=self._DELETE_COMMENT)
-                i += 1
-
-            self._write_warning(f"    Deleted {entries_count}/{entries_count}")
-            self._write_success("Entries deleted. Bye.")

konova/models/geometry.py

@@ -113,7 +113,7 @@ class Geometry(BaseResource):
             objs (list): The list of objects
         """
         objs = []
-        stop_searching = False
+
         # Some related data sets can be processed rather easily
         regular_sets = [
             self.intervention_set,
@@ -129,20 +129,15 @@ class Geometry(BaseResource):
             else:
                 objs += set_objs
 
-            stop_searching = len(objs) > 0
-            if stop_searching:
-                break
-
-        if not stop_searching:
-            # ... but we need a special treatment for compensations, since they can be deleted directly OR inherit their
-            # de-facto-deleted status from their deleted parent intervention
-            comp_objs = self.compensation_set.filter(
-                Q(deleted=None) | Q(intervention__deleted=None)
-            )
-            if limit_to_attrs:
-                objs += comp_objs.values(*limit_to_attrs)
-            else:
-                objs += comp_objs
+        # ... but we need a special treatment for compensations, since they can be deleted directly OR inherit their
+        # de-facto-deleted status from their deleted parent intervention
+        comp_objs = self.compensation_set.filter(
+            Q(deleted=None) & Q(intervention__deleted=None)
+        )
+        if limit_to_attrs:
+            objs += comp_objs.values(*limit_to_attrs)
+        else:
+            objs += comp_objs
         return objs
 
     def get_data_object(self, limit_to_attrs: list = None):
@@ -462,26 +457,6 @@ class Geometry(BaseResource):
         conflict_geoms = Geometry.objects.filter(id__in=conflict_geoms_id)
         return conflict_geoms
 
-    @staticmethod
-    def is_valid_4326(geometry):
-        """ Checks whether a given geometry's coordinates are in a valid range to be of EPSG:4326
-
-        Args:
-            geometry: The geometry
-
-        Returns:
-            ret_val (bool): Whether the geometry is valid EPSG:4326
-        """
-        if not geometry.centroid.coords:
-            # No coordinates at all found, therefore technically proper 4326
-            return True
-
-        try:
-            lat,lon = geometry.centroid.coords
-            return (-90.0 <= lat <= 90.0) and (-180.0 <= lon <= 180.0)
-        except IndexError:
-            return False
-
 
 class GeometryConflict(UuidModel):
     """

konova/models/object.py

@@ -92,15 +92,13 @@ class DeletableObjectMixin(models.Model):
     class Meta:
         abstract = True
 
-    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
+    def mark_as_deleted(self, user, send_mail: bool = True):
         """ Mark an entry as deleted
 
         Does not delete from database but sets a timestamp for being deleted on and which user deleted the object
 
         Args:
             user (User): The performing user
-            send_mail (bool): Whether to send mails to users and teams
-            comment (str|None): The comment for delete action
 
         Returns:
 
@@ -111,7 +109,7 @@ class DeletableObjectMixin(models.Model):
             return
 
         with transaction.atomic():
-            action = UserActionLogEntry.get_deleted_action(user, comment)
+            action = UserActionLogEntry.get_deleted_action(user)
             self.deleted = action
             self.log.add(action)
 

konova/sub_settings/django_settings.py

@@ -191,11 +191,10 @@ STATICFILES_DIRS = [
 ]
 
 # EMAIL (see https://docs.djangoproject.com/en/dev/topics/email/)
-
-# CHANGE_ME !!! ONLY FOR DEVELOPMENT !!!
 if DEBUG:
+    # ONLY FOR DEVELOPMENT NEEDED
     EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
-    EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location
+    EMAIL_FILE_PATH = '/tmp/app-messages'
 
 DEFAULT_FROM_EMAIL = env("DEFAULT_FROM_EMAIL")  # The default email address for the 'from' element
 SERVER_EMAIL = DEFAULT_FROM_EMAIL  # The default email sender address, which is used by Django to send errors via mail

konova/tests/test_geometries.py

@@ -85,6 +85,12 @@ class GeometryTestCase(BaseTestCase):
         )
 
     def test_get_data_objects(self):
+        num_objs_with_geom = 0
+        self.assertEqual(
+            len(self.geom_1.get_data_objects()),
+            num_objs_with_geom
+        )
+
         objs = [
             self.intervention,
             self.compensation,
@@ -92,13 +98,16 @@ class GeometryTestCase(BaseTestCase):
             self.ema,
         ]
         for obj in objs:
-            if not obj.geometry:
-                obj.geometry = Geometry.objects.create(geom=self.create_dummy_geometry())
-                obj.save()
+            obj.geometry = self.geom_1
+            obj.save()
 
-            data_objs = obj.geometry.get_data_objects()
-            self.assertEqual(len(data_objs), 1)
-            self.assertIn(obj, data_objs)
+            num_objs_with_geom += 1
+            geom_objs = self.geom_1.get_data_objects()
+            self.assertEqual(
+                len(geom_objs),
+                num_objs_with_geom
+            )
+            self.assertIn(obj, geom_objs)
 
     def test_as_feature_collection(self):
         geometry = self.geom_1.geom

konova/utils/__init__.py

@@ -1,5 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 16.07.26
-
-"""

konova/utils/schneider/__init__.py

@@ -1,5 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 16.07.26
-
-"""

nginx.conf

@@ -0,0 +1,25 @@
+server {
+    listen 80;
+    client_max_body_size 25M;
+
+    location / {
+        proxy_pass http://127.0.0.1:8000;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header Host $host;
+        proxy_redirect off;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    location /static/ {
+        alias /konova/static/;
+        access_log /var/log/nginx/access.log;
+        autoindex off;
+        types {
+            text/css css;
+            application/javascript js;
+        }
+    }
+
+    error_log /var/log/nginx/error.log;
+}

templates/map/client/config.json

@@ -56,9 +56,11 @@
 	],
 	"layers":
 	[
+		{ "id": "webatlas_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "WebatlasRP farbig", "attribution": "LVermGeo", "url": "https://maps.service24.rlp.de/gisserver/services/RP/RP_WebAtlasRP/MapServer/WmsServer?", "name": "RP_WebAtlasRP", "active": true},
+		{ "id": "webatlas_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "WebatlasRP grau", "attribution": "LVermGeo", "url": "https://maps.service24.rlp.de/gisserver/services/RP/RP_ETRS_Gt/MapServer/WmsServer?", "name": "0", "active": false },
 		{ "id": "luftbilder", "folder": "bg", "type": "WMS", "order": -1, "title": "Luftbilder", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/rp_dop20.fcgi?", "name": "rp_dop20", "active": false },
 		{ "id": "basemap_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE farbig", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_farbe", "active": false },
-		{ "id": "basemap_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE grau", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_grau", "active": true },
+		{ "id": "basemap_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE grau", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_grau", "active": false },
 		{ "id": "dtk_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "DTK5 farbig", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/dtk5_rp.fcgi?", "name": "rp_dtk5", "active": false },
 		{ "id": "dtk_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "DTK5 grau", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/dtk5_rp.fcgi?", "name": "rp_dtk5_grau", "active": false },