authentik.sources.telegram.models

  1"""Telegram source"""
  2
  3from typing import Any
  4from urllib.parse import urlencode
  5
  6from django.db import models
  7from django.http import HttpRequest
  8from django.templatetags.static import static
  9from django.urls import reverse
 10from django.utils.translation import gettext_lazy as _
 11from rest_framework.serializers import BaseSerializer, Serializer
 12
 13from authentik.core.models import (
 14    GroupSourceConnection,
 15    PropertyMapping,
 16    Source,
 17    UserSourceConnection,
 18)
 19from authentik.core.types import UILoginButton, UserSettingSerializer
 20from authentik.flows.challenge import RedirectChallenge
 21from authentik.flows.models import Flow
 22
 23
 24class TelegramSource(Source):
 25    """Log in with Telegram."""
 26
 27    bot_username = models.TextField(help_text=_("Telegram bot username"))
 28    bot_token = models.TextField(help_text=_("Telegram bot token"))
 29
 30    request_message_access = models.BooleanField(
 31        default=False, help_text=_("Request access to send messages from your bot.")
 32    )
 33
 34    pre_authentication_flow = models.ForeignKey(
 35        Flow,
 36        on_delete=models.CASCADE,
 37        help_text=_("Flow used before authentication."),
 38        related_name="telegram_source_pre_authentication",
 39    )
 40
 41    @property
 42    def component(self) -> str:
 43        return "ak-source-telegram-form"
 44
 45    @property
 46    def icon_url(self) -> str | None:
 47        icon = super().icon_url
 48        if not icon:
 49            icon = static("authentik/sources/telegram.svg")
 50        return icon
 51
 52    @property
 53    def serializer(self) -> type[BaseSerializer]:
 54        from authentik.sources.telegram.api.source import TelegramSourceSerializer
 55
 56        return TelegramSourceSerializer
 57
 58    def ui_login_button(self, request: HttpRequest) -> UILoginButton:
 59        return UILoginButton(
 60            challenge=RedirectChallenge(
 61                data={
 62                    "to": reverse(
 63                        "authentik_sources_telegram:start",
 64                        kwargs={"source_slug": self.slug},
 65                    ),
 66                }
 67            ),
 68            name=self.name,
 69            icon_url=self.icon_url,
 70            promoted=self.promoted,
 71        )
 72
 73    def ui_user_settings(self) -> UserSettingSerializer | None:
 74        return UserSettingSerializer(
 75            data={
 76                "title": self.name,
 77                "component": "ak-user-settings-source-telegram",
 78                "icon_url": self.icon_url,
 79                "configure_url": urlencode(
 80                    {
 81                        "bot_username": self.bot_username,
 82                        "request_message_access": str(self.request_message_access),
 83                    }
 84                ),
 85            }
 86        )
 87
 88    @property
 89    def property_mapping_type(self) -> type[PropertyMapping]:
 90        return TelegramSourcePropertyMapping
 91
 92    def get_base_user_properties(
 93        self, info: dict[str, Any] | None = None, **kwargs
 94    ) -> dict[str, Any | dict[str, Any]]:
 95        info = info or {}
 96        name = info.get("first_name", "")
 97        if "last_name" in info:
 98            name += " " + info["last_name"]
 99        return {
100            "username": info.get("username", None),
101            "email": None,
102            "name": name if name else None,
103        }
104
105    def get_base_group_properties(self, group_id: str, **kwargs):
106        return {
107            "name": group_id,
108        }
109
110    class Meta:
111        verbose_name = _("Telegram Source")
112        verbose_name_plural = _("Telegram Sources")
113
114
115class TelegramSourcePropertyMapping(PropertyMapping):
116    """Map Telegram properties to User or Group object attributes"""
117
118    @property
119    def component(self) -> str:
120        return "ak-property-mapping-source-telegram-form"
121
122    @property
123    def serializer(self) -> type[Serializer]:
124        from authentik.sources.telegram.api.property_mappings import (
125            TelegramSourcePropertyMappingSerializer,
126        )
127
128        return TelegramSourcePropertyMappingSerializer
129
130    class Meta:
131        verbose_name = _("Telegram Source Property Mapping")
132        verbose_name_plural = _("Telegram Source Property Mappings")
133
134
135class UserTelegramSourceConnection(UserSourceConnection):
136    """Connect user and Telegram source"""
137
138    @property
139    def serializer(self) -> type[Serializer]:
140        from authentik.sources.telegram.api.source_connection import (
141            UserTelegramSourceConnectionSerializer,
142        )
143
144        return UserTelegramSourceConnectionSerializer
145
146    class Meta:
147        verbose_name = _("User Telegram Source Connection")
148        verbose_name_plural = _("User Telegram Source Connections")
149
150
151class GroupTelegramSourceConnection(GroupSourceConnection):
152    """Group-source connection for Telegram"""
153
154    @property
155    def serializer(self) -> type[Serializer]:
156        from authentik.sources.telegram.api.source_connection import (
157            GroupTelegramSourceConnectionSerializer,
158        )
159
160        return GroupTelegramSourceConnectionSerializer
161
162    class Meta:
163        verbose_name = _("Group Telegram Source Connection")
164        verbose_name_plural = _("Group Telegram Source Connections")