Export page access statistics

.eslintrc.js

@@ -64,7 +64,6 @@ module.exports = {
         "implicit-arrow-linebreak": "off",
         "max-len": "off",
         "no-confusing-arrow": "off",
-        "no-console": "off",
         "no-multiple-empty-lines": "off",
         "object-curly-newline": "off",
         "operator-linebreak": "off",
@@ -137,6 +136,7 @@ module.exports = {
         "react/function-component-definition": ["error", { namedComponents: "arrow-function" }],
         "react-hooks/exhaustive-deps": "error",
         "vars-on-top": "error",
+        "no-console": ["error", { allow: ["debug", "warn", "error"] }],
     },
     overrides: [
         {

integreat_cms/api/v3/chat/utils/chat_bot.py

@@ -4,96 +4,124 @@
 
 from __future__ import annotations
 
-import requests
+import asyncio
+
+import aiohttp
 from celery import shared_task
 from django.conf import settings
 
 from integreat_cms.cms.models import Region, UserChat
-from integreat_cms.cms.utils.content_translation_utils import (
-    get_public_translation_for_link,
-)
 
 from .zammad_api import ZammadChatAPI
 
 
-def format_message(response: dict) -> str:
+async def automatic_answer(
+    message: str, region_slug: str, language_slug: str, session: aiohttp.ClientSession
+) -> dict:
     """
-    Transform JSON into readable message
-    """
-    if "answer" not in response or not response["answer"]:
-        raise ValueError("Could not format message, no answer attribute in response")
-    if "sources" not in response or not response["sources"]:
-        return response["answer"]
-    sources = "".join(
-        [
-            f"<li><a href='{settings.WEBAPP_URL}{path}'>{title}</a></li>"
-            for path in response["sources"]
-            if (title := get_public_translation_for_link(settings.WEBAPP_URL + path))
-        ]
-    )
-    return f"{response['answer']}\n<ul>{sources}</ul>"
-
-
-def automatic_answer(message: str, region: Region, language_slug: str) -> str | None:
-    """
-    Get automatic answer to question
+    Get automatic answer to question asynchronously
     """
     url = (
         f"https://{settings.INTEGREAT_CHAT_BACK_END_DOMAIN}/chatanswers/extract_answer/"
     )
-    body = {"message": message, "language": language_slug, "region": region.slug}
-    r = requests.post(url, json=body, timeout=settings.INTEGREAT_CHAT_BACK_END_TIMEOUT)
-    return format_message(r.json())
+    body = {"message": message, "language": language_slug, "region": region_slug}
+    async with session.post(
+        url, json=body, timeout=settings.INTEGREAT_CHAT_BACK_END_TIMEOUT
+    ) as response:
+        return await response.json()
 
 
-def automatic_translation(
-    message: str, source_language_slug: str, target_language_slug: str
-) -> str:
+async def automatic_translation(
+    message: str,
+    source_language_slug: str,
+    target_language_slug: str,
+    session: aiohttp.ClientSession,
+) -> dict:
     """
-    Use LLM to translate message
+    Use LLM to translate message asynchronously
     """
     url = f"https://{settings.INTEGREAT_CHAT_BACK_END_DOMAIN}/chatanswers/translate_message/"
     body = {
         "message": message,
         "source_language": source_language_slug,
         "target_language": target_language_slug,
     }
-    response = requests.post(
+    async with session.post(
         url, json=body, timeout=settings.INTEGREAT_CHAT_BACK_END_TIMEOUT
-    ).json()
-    if "status" in response and response["status"] == "success":
-        return response["translation"]
-    raise ValueError("Did not receive success response for translation request.")
+    ) as response:
+        return await response.json()
+
+
+async def async_process_user_message(
+    zammad_chat_language_slug: str,
+    region_slug: str,
+    region_default_language_slug: str,
+    message_text: str,
+) -> tuple[dict, dict]:
+    """
+    Process the message from an Integreat App user
+    """
+    async with aiohttp.ClientSession() as session:
+        translation_task = automatic_translation(
+            message_text,
+            zammad_chat_language_slug,
+            region_default_language_slug,
+            session,
+        )
+        answer_task = automatic_answer(
+            message_text, region_slug, zammad_chat_language_slug, session
+        )
+        translation, answer = await asyncio.gather(translation_task, answer_task)
+        return translation, answer
 
 
 @shared_task
 def process_user_message(
     message_text: str, region_slug: str, zammad_ticket_id: int
 ) -> None:
     """
-    Process the message from an Integreat App user
+    Call the async processing of the message from an Integreat App user
     """
     zammad_chat = UserChat.objects.get(zammad_id=zammad_ticket_id)
     region = Region.objects.get(slug=region_slug)
     client = ZammadChatAPI(region)
-    if translation := automatic_translation(
-        message_text, zammad_chat.language.slug, region.default_language.slug
-    ):
+    translation, answer = asyncio.run(
+        async_process_user_message(
+            zammad_chat.language.slug,
+            region_slug,
+            region.default_language.slug,
+            message_text,
+        )
+    )
+    if translation:
         client.send_message(
             zammad_chat.zammad_id,
-            translation,
+            translation["translation"],
             True,
             True,
         )
-    if answer := automatic_answer(message_text, region, zammad_chat.language.slug):
+    if answer:
         client.send_message(
             zammad_chat.zammad_id,
-            answer,
+            answer["answer"],
             False,
             True,
         )
 
 
+async def async_process_answer(
+    message_text: str, source_language: str, target_language: str
+) -> dict:
+    """
+    Process automatic or counselor answers
+    """
+    async with aiohttp.ClientSession() as session:
+        translation_task = automatic_translation(
+            message_text, source_language, target_language, session
+        )
+        return await translation_task
+
+
 @shared_task
 def process_answer(message_text: str, region_slug: str, zammad_ticket_id: int) -> None:
     """
@@ -102,12 +130,15 @@ def process_answer(message_text: str, region_slug: str, zammad_ticket_id: int) -
     zammad_chat = UserChat.objects.get(zammad_id=zammad_ticket_id)
     region = Region.objects.get(slug=region_slug)
     client = ZammadChatAPI(region)
-    if translation := automatic_translation(
-        message_text, region.default_language.slug, zammad_chat.language.slug
-    ):
+    translation = asyncio.run(
+        async_process_answer(
+            message_text, region.default_language.slug, zammad_chat.language.slug
+        )
+    )
+    if translation:
         client.send_message(
             zammad_chat.zammad_id,
-            translation,
+            translation["translation"],
             False,
             True,
         )

integreat_cms/api/v3/chat/utils/zammad_api.py

@@ -142,7 +142,7 @@ def _transform_attachment(
             )[0].random_hash,
         }
 
-    def get_messages(self, chat: UserChat) -> dict[str, dict | list[dict]]:
+    def get_messages(self, chat: UserChat) -> dict[str, dict | list[dict] | str]:
         # pylint: disable=method-hidden
         """
         Get all non-internal messages for a given ticket
@@ -163,7 +163,10 @@ def get_messages(self, chat: UserChat) -> dict[str, dict | list[dict]]:
                     for attachment in message["attachments"]
                 ]
 
-        return {"messages": response}
+        return {
+            "messages": response,
+            "ticket_url": f"{chat.region.zammad_url}/#ticket/zoom/{chat.zammad_id}",
+        }
 
     def send_message(
         self,

integreat_cms/cms/constants/calendar.py

@@ -0,0 +1,30 @@
+"""
+This module contains all string representations of calendar filter options, used by :class:`~integreat_cms.cms.forms.events.event_filter_form.EventFilterForm` and
+:class:`~integreat_cms.cms.views.events.event_list_view.EventListView`:
+
+The module also contains a constant :const:`~integreat_cms.cms.constants.calendar.DATATYPE` which contains the type of the constant values linked to the strings and is used for correctly
+instantiating :class:`django.forms.TypedMultipleChoiceField` instances in :class:`~integreat_cms.cms.forms.events.event_filter_form.EventFilterForm`.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.utils.translation import gettext_lazy as _
+
+if TYPE_CHECKING:
+    from typing import Final
+
+    from django.utils.functional import Promise
+
+DATATYPE: Final = int
+
+EVENT_NOT_FROM_EXTERNAL_CALENDAR: Final = 1
+#: Events that are not recurring, i.e. take place only once
+EVENT_FROM_EXTERNAL_CALENDAR: Final = 2
+
+#: Choices to use these constants in a database field
+CHOICES: Final[list[tuple[int, Promise]]] = [
+    (EVENT_NOT_FROM_EXTERNAL_CALENDAR, _("Event not from an external calendar")),
+    (EVENT_FROM_EXTERNAL_CALENDAR, _("Event from an external calendar")),
+]