django-slack-tools 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

django_slack_tools/slack_messages/message.py

@@ -2,29 +2,32 @@
 
 from __future__ import annotations
 
-from logging import getLogger
+import logging
 from typing import TYPE_CHECKING, Any
 
 from django_slack_tools.app_settings import app_settings
-from django_slack_tools.utils.dict_template import render
+from django_slack_tools.slack_messages.models.message_recipient import SlackMessageRecipient
 from django_slack_tools.utils.slack import MessageBody, MessageHeader
 
 from .models import SlackMessagingPolicy
 
-logger = getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from .models import SlackMention, SlackMessage
+    from django_slack_tools.slack_messages.backends.base import BaseBackend
 
+    from .models import SlackMessage
 
-def slack_message(
+
+def slack_message(  # noqa: PLR0913
     body: str | MessageBody | dict[str, Any],
     *,
     channel: str,
     header: MessageHeader | dict[str, Any] | None = None,
     raise_exception: bool = False,
     get_permalink: bool = False,
-) -> SlackMessage | None:
+    backend: BaseBackend = app_settings.backend,
+) -> SlackMessage:
     """Send a simple text message.
 
     Args:
@@ -33,96 +36,75 @@ def slack_message(
         header: Slack message control header.
         raise_exception: Whether to re-raise caught exception while sending messages.
         get_permalink: Try to get the message permalink via extraneous Slack API calls.
+        backend: Messaging backend. If not set, use `app_settings.backend`.
 
     Returns:
         Sent message instance or `None`.
     """
-    # If body is just an string, make a simple message body
-    body = MessageBody(text=body) if isinstance(body, str) else MessageBody.model_validate(body)
-    header = MessageHeader.model_validate(header or {})
+    body = MessageBody.from_any(body)
+    header = MessageHeader.from_any(header)
+    message = backend.prepare_message(channel=channel, header=header, body=body)
 
-    return app_settings.backend.send_message(
-        channel=channel,
-        header=header,
-        body=body,
-        raise_exception=raise_exception,
-        get_permalink=get_permalink,
-    )
+    return backend.send_message(message, raise_exception=raise_exception, get_permalink=get_permalink)
 
 
 def slack_message_via_policy(  # noqa: PLR0913
-    policy: str | SlackMessagingPolicy,
+    policy: str | SlackMessagingPolicy = app_settings.default_policy_code,
     *,
     header: MessageHeader | dict[str, Any] | None = None,
     raise_exception: bool = False,
     lazy: bool = False,
     get_permalink: bool = False,
     context: dict[str, Any] | None = None,
-) -> list[SlackMessage | None]:
+    backend: BaseBackend = app_settings.backend,
+) -> int:
     """Send a simple text message.
 
-    Mentions for each recipient will be passed to template as keyword `{mentions}`.
-    Template should include it to use mentions.
+    Some default context variables are populated and available for use in templates.
+    See corresponding backend implementation for available context variables.
 
     Args:
-        policy: Messaging policy code or policy instance.
+        policy: Messaging policy code or policy instance. Defaults to app's default policy.
         header: Slack message control header.
         raise_exception: Whether to re-raise caught exception while sending messages.
         lazy: Decide whether try create policy with disabled, if not exists.
         get_permalink: Try to get the message permalink via extraneous Slack API calls.
         context: Dictionary to pass to template for rendering.
+        backend: Messaging backend. If not set, use `app_settings.backend`.
 
     Returns:
-        Sent message instance or `None`.
+        Count of messages sent successfully.
 
     Raises:
         SlackMessagingPolicy.DoesNotExist: Policy for given code does not exists.
     """
     if isinstance(policy, str):
         if lazy:
-            policy, created = SlackMessagingPolicy.objects.get_or_create(code=policy, defaults={"enabled": False})
+            policy, created = SlackMessagingPolicy.objects.get_or_create(
+                code=policy,
+                defaults={
+                    "enabled": app_settings.lazy_policy_enabled,
+                    "template": app_settings.default_template,
+                },
+            )
             if created:
+                # Add default recipient for created policy
+                recipient = SlackMessageRecipient.objects.get(alias=app_settings.default_recipient)
+                policy.recipients.add(recipient)
                 logger.warning("Policy for code %r created because `lazy` is set.", policy)
         else:
             policy = SlackMessagingPolicy.objects.get(code=policy)
 
-    if not policy.enabled:
-        return []
-
-    header = MessageHeader.model_validate(header or {})
+    header = MessageHeader.from_any(header)
     context = context or {}
 
-    # Prepare template
-    template = policy.template
-    overridden_reserved = {"mentions", "mentions_as_str"} & set(context.keys())
-    if overridden_reserved:
+    messages = backend.prepare_messages_from_policy(policy, header=header, context=context)
+    if not policy.enabled:
         logger.warning(
-            "Template keyword argument(s) %s reserved for passing mentions, but already exists."
-            " User provided value will override it.",
-            ", ".join(f"`{s}`" for s in overridden_reserved),
-        )
-
-    messages: list[SlackMessage | None] = []
-    for recipient in policy.recipients.all():
-        # Auto-generated reserved kwargs
-        mentions: list[SlackMention] = list(recipient.mentions.all())
-        mentions_as_str = ", ".join(mention.mention for mention in mentions)
-
-        # Prepare rendering arguments
-        kwargs = {"mentions": mentions, "mentions_as_str": mentions_as_str}
-        kwargs.update(context)
-
-        # Render and send message
-        rendered = render(template, **kwargs)
-        body = MessageBody.model_validate(rendered)
-        message = app_settings.backend.send_message(
-            policy=policy,
-            channel=recipient.channel,
-            header=header,
-            body=body,
-            raise_exception=raise_exception,
-            get_permalink=get_permalink,
+            "Created %d messages but not sending because policy %s is not enabled.",
+            len(messages),
+            policy.code,
         )
-        messages.append(message)
+        return 0
 
-    return messages
+    return backend.send_messages(*messages, raise_exception=raise_exception, get_permalink=get_permalink)

django_slack_tools/slack_messages/migrations/0001_initial.py

@@ -3,7 +3,6 @@
 import django.db.models.deletion
 from django.db import migrations, models
 
-import django_slack_tools.utils.dict_template
 import django_slack_tools.utils.slack.django
 
 
@@ -163,7 +162,6 @@ class Migration(migrations.Migration):
                         blank=True,
                         help_text="Dictionary-based template object.",
                         null=True,
-                        validators=[django_slack_tools.utils.dict_template.dict_template_validator],
                         verbose_name="Message template object",
                     ),
                 ),

django_slack_tools/slack_messages/migrations/0002_default_policy.py

@@ -0,0 +1,35 @@
+# Generated by Django 4.2.11 on 2024-04-09 13:39
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+
+if TYPE_CHECKING:
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+    from django.db.migrations.state import StateApps
+
+
+def _create_default_policy(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    db_alias = schema_editor.connection.alias
+    model_type = apps.get_model("slack_messages", "SlackMessagingPolicy")
+    model_type.objects.using(db_alias).create(code="DEFAULT", enabled=False)
+
+
+def _delete_default_policy(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    db_alias = schema_editor.connection.alias
+    model_type = apps.get_model("slack_messages", "SlackMessagingPolicy")
+    model_type.objects.using(db_alias).filter(code="DEFAULT").delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("slack_messages", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            code=_create_default_policy,
+            reverse_code=_delete_default_policy,
+        ),
+    ]

django_slack_tools/slack_messages/migrations/0003_default_recipient.py

@@ -0,0 +1,35 @@
+# Generated by Django 4.2.11 on 2024-04-09 13:39
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from django.db import migrations
+
+if TYPE_CHECKING:
+    from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+    from django.db.migrations.state import StateApps
+
+
+def _create_default_recipient(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    db_alias = schema_editor.connection.alias
+    model_type = apps.get_model("slack_messages", "SlackMessageRecipient")
+    model_type.objects.using(db_alias).create(alias="DEFAULT")
+
+
+def _delete_default_recipient(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    db_alias = schema_editor.connection.alias
+    model_type = apps.get_model("slack_messages", "SlackMessageRecipient")
+    model_type.objects.using(db_alias).filter(alias="DEFAULT").delete()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("slack_messages", "0002_default_policy"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            code=_create_default_recipient,
+            reverse_code=_delete_default_recipient,
+        ),
+    ]

django_slack_tools/slack_messages/migrations/0004_slackmessagingpolicy_template_type.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.16 on 2024-10-19 05:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("slack_messages", "0003_default_recipient"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="slackmessagingpolicy",
+            name="template_type",
+            field=models.CharField(
+                choices=[("D", "Dictionary"), ("DJ", "Django"), ("DI", "Django Inline"), ("?", "Unknown")],
+                default="D",
+                help_text="Type of message template.",
+                max_length=2,
+                verbose_name="Template type",
+            ),
+        ),
+    ]

django_slack_tools/slack_messages/models/messaging_policy.py

@@ -2,15 +2,19 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from django.db import models
 from django.utils.translation import gettext_lazy as _
 
-from django_slack_tools.utils.dict_template import dict_template_validator
 from django_slack_tools.utils.model_mixins import TimestampMixin
 from django_slack_tools.utils.slack import header_validator
 
 from .message_recipient import SlackMessageRecipient
 
+if TYPE_CHECKING:
+    from typing import Any
+
 
 class SlackMessagingPolicyManager(models.Manager["SlackMessagingPolicy"]):
     """Manager for Slack messaging policies."""
@@ -19,6 +23,21 @@ class SlackMessagingPolicyManager(models.Manager["SlackMessagingPolicy"]):
 class SlackMessagingPolicy(TimestampMixin, models.Model):
     """An Slack messaging policy which determines message content and those who receive messages."""
 
+    class TemplateType(models.TextChoices):
+        """Possible template types."""
+
+        DICT = "D", _("Dictionary")
+        "Dictionary-based template."
+
+        DJANGO = "DJ", _("Django")
+        "Django XML-based template."
+
+        DJANGO_INLINE = "DI", _("Django Inline")
+        "Django inline template."
+
+        UNKNOWN = "?", _("Unknown")
+        "Unknown template type."
+
     code = models.CharField(
         verbose_name=_("Code"),
         help_text=_("Unique message code for lookup, mostly by human."),
@@ -42,13 +61,20 @@ class SlackMessagingPolicy(TimestampMixin, models.Model):
         blank=True,
         default=dict,
     )
-    template = models.JSONField(
+    template_type = models.CharField(
+        verbose_name=_("Template type"),
+        help_text=_("Type of message template."),
+        max_length=2,
+        choices=TemplateType.choices,
+        default=TemplateType.DICT,
+    )
+    template: models.JSONField[Any] = models.JSONField(
         verbose_name=_("Message template object"),
         help_text=_("Dictionary-based template object."),
-        validators=[dict_template_validator],
         null=True,
         blank=True,
     )
+
     # Type is too obvious but due to limits...
     objects: SlackMessagingPolicyManager = SlackMessagingPolicyManager()
 

django_slack_tools/slack_messages/tasks.py

@@ -0,0 +1,112 @@
+"""Celery utils."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING
+
+from celery import shared_task
+from celery.utils.log import get_task_logger
+from django.utils import timezone
+
+from django_slack_tools.slack_messages import message
+from django_slack_tools.slack_messages.models import SlackMessage
+
+if TYPE_CHECKING:
+    from typing import Any
+
+logger = get_task_logger(__name__)
+
+
+@shared_task
+def slack_message(
+    body: str | dict[str, Any],
+    *,
+    channel: str,
+    header: dict[str, Any] | None = None,
+    raise_exception: bool = False,
+    get_permalink: bool = False,
+) -> int | None:
+    """Celery task wrapper for `message.slack_message`.
+
+    Args:
+        body: Message content, simple message or full request body.
+        channel: Channel to send message.
+        header: Slack message control header.
+        raise_exception: Whether to re-raise caught exception while sending messages.
+        get_permalink: Try to get the message permalink via extraneous Slack API calls.
+
+    Returns:
+        ID of sent message.
+    """
+    sent_msg = message.slack_message(
+        body,
+        channel=channel,
+        header=header,
+        raise_exception=raise_exception,
+        get_permalink=get_permalink,
+    )
+    return sent_msg.id
+
+
+@shared_task
+def slack_message_via_policy(  # noqa: PLR0913
+    policy: str,
+    *,
+    header: dict[str, Any] | None = None,
+    raise_exception: bool = False,
+    lazy: bool = False,
+    get_permalink: bool = False,
+    context: dict[str, Any] | None = None,
+) -> int:
+    """Celery task wrapper for `message.slack_message_via_policy`.
+
+    Args:
+        policy: Messaging policy code.
+        header: Slack message control header.
+        raise_exception: Whether to re-raise caught exception while sending messages.
+        lazy: Decide whether try to create policy with disabled, if not exists.
+        get_permalink: Try to get the message permalink via extraneous Slack API calls.
+        context: Context variables for message rendering.
+
+    Returns:
+        Number of sent messages.
+    """
+    return message.slack_message_via_policy(
+        policy,
+        header=header,
+        raise_exception=raise_exception,
+        lazy=lazy,
+        get_permalink=get_permalink,
+        context=context,
+    )
+
+
+@shared_task
+def cleanup_old_messages(
+    *,
+    base_ts: str | None = None,
+    threshold_seconds: int | None = 7 * 24 * 60 * 60,  # 7 days
+) -> int:
+    """Delete old messages created before given threshold.
+
+    Args:
+        threshold_seconds: Threshold seconds. Defaults to 7 days.
+        base_ts: Base timestamp to calculate the threshold, in ISO format. If falsy, current timestamp will be used.
+
+    Returns:
+        Number of deleted messages.
+    """
+    dt = datetime.fromisoformat(base_ts) if base_ts else timezone.localtime()
+
+    if threshold_seconds is None:
+        logger.warning("Threshold seconds not provided, skipping cleanup.")
+        return 0
+
+    cleanup_threshold = dt - timedelta(seconds=threshold_seconds)
+    logger.debug("Cleaning up messages older than %s.", cleanup_threshold)
+
+    num_deleted, _ = SlackMessage.objects.filter(created__lt=cleanup_threshold).delete()
+    logger.info("Deleted %d old messages.", num_deleted)
+
+    return num_deleted

django_slack_tools/utils/slack/django.py

@@ -2,44 +2,28 @@
 
 from __future__ import annotations
 
-from typing import Any
-
-import pydantic
 from django.core.exceptions import ValidationError
-from django.utils.translation import gettext_lazy as _
 
 from .message import MessageBody, MessageHeader
 
 
-def header_validator(value: Any) -> None:
+def header_validator(d: dict) -> None:
     """Validate given value is valid message header."""
     try:
-        MessageHeader.model_validate(value)
-    except pydantic.ValidationError as exc:
+        MessageHeader.from_any(d)
+    except Exception as exc:
         err = _convert_errors(exc)
         raise err from exc
 
 
-def body_validator(value: Any) -> None:
+def body_validator(d: dict) -> None:
     """Validate given value is valid message body."""
     try:
-        MessageBody.model_validate(value)
-    except pydantic.ValidationError as exc:
+        MessageBody.from_any(d)
+    except Exception as exc:
         err = _convert_errors(exc)
         raise err from exc
 
 
-def _convert_errors(exc: pydantic.ValidationError) -> ValidationError:
-    """Convert Pydantic validation error to Django error."""
-    errors = [
-        ValidationError(
-            _("Input validation failed [msg=%(msg)r, input=%(input)r]"),
-            code=", ".join(map(str, err["loc"])),
-            params={
-                "msg": err["msg"],
-                "input": err["input"],
-            },
-        )
-        for err in exc.errors()
-    ]
-    return ValidationError(errors)
+def _convert_errors(exc: Exception) -> ValidationError:
+    return ValidationError(str(exc))

django_slack_tools/utils/slack/message.py

@@ -2,43 +2,92 @@
 
 from __future__ import annotations
 
-from typing import List, Optional
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
 
-from pydantic import BaseModel, model_validator
+if TYPE_CHECKING:
+    from typing import Any, List, Optional
 
+NoneType = type(None)
 
-class MessageHeader(BaseModel):
-    """Type definition for message header."""
 
-    # NOTE: `channel` is omitted to handle it in recipients
-    #       Because extra fields not forbidden for reasons, channel can be passed but not recommended
+@dataclass
+class MessageHeader:
+    """Message header data definition."""
 
-    mrkdwn: Optional[str] = None  # noqa: UP007
-    parse: Optional[str] = None  # noqa: UP007
-    reply_broadcast: Optional[bool] = None  # noqa: UP007
-    thread_ts: Optional[str] = None  # noqa: UP007
-    unfurl_links: Optional[bool] = None  # noqa: UP007
-    unfurl_media: Optional[bool] = None  # noqa: UP007
+    mrkdwn: Optional[str] = field(default=None)  # noqa: UP007
+    parse: Optional[str] = field(default=None)  # noqa: UP007
+    reply_broadcast: Optional[bool] = field(default=None)  # noqa: UP007
+    thread_ts: Optional[str] = field(default=None)  # noqa: UP007
+    unfurl_links: Optional[bool] = field(default=None)  # noqa: UP007
+    unfurl_media: Optional[bool] = field(default=None)  # noqa: UP007
 
+    def __post_init__(self) -> None:
+        _assert_type(self.mrkdwn, (str, NoneType))
+        _assert_type(self.parse, (str, NoneType))
+        _assert_type(self.reply_broadcast, (bool, NoneType))
+        _assert_type(self.thread_ts, (str, NoneType))
+        _assert_type(self.unfurl_links, (bool, NoneType))
+        _assert_type(self.unfurl_media, (bool, NoneType))
 
-class MessageBody(BaseModel):
-    """Type definition for message body."""
+    @classmethod
+    def from_any(
+        cls,
+        obj: MessageHeader | dict[str, Any] | None = None,
+    ) -> MessageHeader:
+        """Create instance from compatible types."""
+        if obj is None:
+            return cls()
 
-    attachments: Optional[List[dict]] = None  # noqa: UP006, UP007
+        if isinstance(obj, dict):
+            return cls(**obj)
+
+        msg = f"Unsupported type {type(obj)}"
+        raise TypeError(msg)
+
+
+@dataclass
+class MessageBody:
+    """Data definition for message body."""
+
+    attachments: Optional[List[dict]] = field(default=None)  # noqa: UP006, UP007
 
     # See more about blocks at https://api.slack.com/reference/block-kit/blocks
-    blocks: Optional[List[dict]] = None  # noqa: UP006, UP007
+    blocks: Optional[List[dict]] = field(default=None)  # noqa: UP006, UP007
+
+    text: Optional[str] = field(default=None)  # noqa: UP007
+    icon_emoji: Optional[str] = field(default=None)  # noqa: UP007
+    icon_url: Optional[str] = field(default=None)  # noqa: UP007
+    metadata: Optional[dict] = field(default=None)  # noqa: UP007
+    username: Optional[str] = field(default=None)  # noqa: UP007
 
-    text: Optional[str] = None  # noqa: UP007
-    icon_emoji: Optional[str] = None  # noqa: UP007
-    icon_url: Optional[str] = None  # noqa: UP007
-    metadata: Optional[dict] = None  # noqa: UP007
-    username: Optional[str] = None  # noqa: UP007
+    def __post_init__(self) -> None:
+        _assert_type(self.attachments, (list, NoneType))
+        _assert_type(self.blocks, (list, NoneType))
+        _assert_type(self.text, (str, NoneType))
+        _assert_type(self.icon_emoji, (str, NoneType))
+        _assert_type(self.icon_url, (str, NoneType))
+        _assert_type(self.metadata, (dict, NoneType))
+        _assert_type(self.username, (str, NoneType))
 
-    @model_validator(mode="after")
-    def _check_one_of_exists(self) -> MessageBody:
-        if not self.attachments and not self.blocks and not self.text:
+        if not any((self.attachments, self.blocks, self.text)):
             msg = "At least one of `attachments`, `blocks` and `text` must set"
             raise ValueError(msg)
 
-        return self
+    @classmethod
+    def from_any(cls, obj: str | MessageBody | dict[str, Any]) -> MessageBody:
+        """Create instance from compatible types."""
+        if isinstance(obj, dict):
+            return cls(**obj)
+
+        if isinstance(obj, str):
+            return cls(text=obj)
+
+        msg = f"Unsupported type {type(obj)}"
+        raise TypeError(msg)
+
+
+def _assert_type(obj: Any, cls: type | tuple[type, ...]) -> None:
+    if not isinstance(obj, cls):
+        msg = f"Invalid value type, expected {cls}, got {type(obj)}"
+        raise TypeError(msg)

django_slack_tools/utils/template/__init__.py

@@ -0,0 +1,5 @@
+from .base import BaseTemplate
+from .dict import DictTemplate
+from .django import DjangoTemplate
+
+__all__ = ("BaseTemplate", "DictTemplate", "DjangoTemplate")

django_slack_tools/utils/template/base.py

@@ -0,0 +1,17 @@
+"""Abstraction for dictionary templates."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+class BaseTemplate(ABC):
+    """Abstract base class for dictionary templates."""
+
+    @abstractmethod
+    def render(self, *, context: dict[str, Any] | None = None) -> dict:
+        """Render template with given context."""