wbmailing 2.2.1__py2.py3-none-any.whl

wbmailing/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbmailing/admin.py

@@ -0,0 +1,74 @@
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+
+from .models import (
+    Mail,
+    MailEvent,
+    MailingList,
+    MailingListEmailContactThroughModel,
+    MailingListSubscriberChangeRequest,
+    MailTemplate,
+    MassMail,
+)
+
+
+class MailingListEmailContactThroughInlineAdmin(admin.TabularInline):
+    model = MailingListEmailContactThroughModel
+    fk_name = "mailing_list"
+    autocomplete_fields = ["email_contact"]
+
+
+@admin.register(MailingList)
+class MailingListAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["email_contacts"]
+    search_fields = ["title"]
+    inlines = [
+        MailingListEmailContactThroughInlineAdmin,
+    ]
+
+
+@admin.register(MassMail)
+class MassMailAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["creator"]
+
+    def send_test_mail(self, request, queryset):
+        for mass_mail in queryset:
+            mass_mail.send_test_mail(request.user)
+
+    actions = [send_test_mail]
+
+
+@admin.register(MailingListSubscriberChangeRequest)
+class MailingListSubscriberChangeRequestAdmin(admin.ModelAdmin):
+    list_display = ("email_contact", "mailing_list", "status")
+    autocomplete_fields = ["email_contact", "requester"]
+
+
+admin.site.register(MailEvent)
+
+
+class MailEventInline(admin.TabularInline):
+    model = MailEvent
+    fields = ("timestamp", "event_type", "reject_reason", "recipient", "user_agent", "tags", "description")
+    readonly_fields = ("timestamp", "event_type", "reject_reason", "recipient", "user_agent", "tags", "description")
+    extra = 0
+    can_delete = False
+
+
+@admin.register(Mail)
+class MailAdmin(admin.ModelAdmin):
+    def send_mails(self, request, queryset):
+        for mail in queryset:
+            mail.resend()
+
+    send_mails.short_description = _("Send Emails")
+    actions = [send_mails]
+    search_fields = ["mass_mail__subject", "from_email", "to_email__address", "subject", "message_ids"]
+    autocomplete_fields = ["to_email", "cc_email", "bcc_email"]
+
+    inlines = [MailEventInline]
+
+
+@admin.register(MailTemplate)
+class MailTemplateAdmin(admin.ModelAdmin):
+    pass

wbmailing/apps.py

@@ -0,0 +1,14 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+class WbmailingConfig(AppConfig):
+    name = "wbmailing"
+
+    def ready(self) -> None:
+        from wbmailing.management import initialize_task
+
+        post_migrate.connect(
+            initialize_task,
+            dispatch_uid="wbmailing.initialize_task",
+        )

wbmailing/backend.py

@@ -0,0 +1,131 @@
+from datetime import timedelta
+
+from anymail.backends.mailgun import EmailBackend as AnymailMailgunBackend
+from anymail.backends.mailjet import EmailBackend as AnymailMailjetBackend
+from anymail.backends.mandrill import EmailBackend as AnymailMandrillBackend
+from anymail.backends.postmark import EmailBackend as AnymailPostmarkBackend
+from anymail.backends.sendgrid import EmailBackend as AnymailSendgridBackend
+from anymail.backends.sendinblue import EmailBackend as AnymailSendinblueBackend
+from anymail.exceptions import AnymailError
+from django.conf import settings
+from django.core.mail.backends.console import EmailBackend as ConsoleBackend
+from django.utils import timezone
+from sentry_sdk import capture_message
+from wbcore.utils.html import convert_html2text
+from wbmailing.models import Mail, MailEvent
+
+
+class SendMessagesMixin:
+    def _process_msg(self, message):
+        mail = message.mail if hasattr(message, "mail") else None
+        mass_mail = message.mass_mail if hasattr(message, "mass_mail") else None
+        if mail:
+            event_type = MailEvent.EventType.RESENT
+        else:
+            if not hasattr(message, "silent_mail") or (hasattr(message, "silent_mail") and not message.silent_mail):
+                mail = Mail.create_mail_from_mailmessage(message, user=getattr(message, "user", None))
+            event_type = MailEvent.EventType.CREATED
+        if mass_mail:
+            message.tags = [f"massmail-{mass_mail.id}"]
+        else:
+            message.tags = [f"mail-{mail.id}"]
+        if mail and mail.body:
+            # We reset the body text and html field with what might have been computed in create_mail_from_mailmessage
+            message.body = convert_html2text(mail.body)
+            message.alternatives = []
+            message.attach_alternative(mail.body, "text/html")
+        return event_type, mail
+
+    def send_messages(self, email_messages):
+        """
+        Sends one or more EmailMessage objects and returns the number of email
+        messages sent.
+        """
+        # This API is specified by Django's core BaseEmailBackend
+        # (so you can't change it to, e.g., return detailed status).
+        # Subclasses shouldn't need to override.
+        from wbmailing.models import MailEvent
+
+        num_sent = 0
+        if not email_messages:
+            return num_sent
+
+        created_session = self.open()
+
+        try:
+            for message in email_messages:
+                try:
+                    event_type, mail = self._process_msg(message)
+                    sent = self._send(message)
+                    if mail:
+                        MailEvent.objects.create(
+                            mail=mail, event_type=event_type, timestamp=timezone.now() - timedelta(seconds=1)
+                        )
+                        mail.message_ids.append(message.anymail_status.message_id)
+                        mail.last_send = timezone.now()
+                        mail.save()
+                except AnymailError as e:
+                    capture_message(e)
+                    if self.fail_silently:
+                        sent = False
+                    else:
+                        raise
+                if sent:
+                    num_sent += 1
+        finally:
+            if created_session:
+                self.close()
+
+        return num_sent
+
+
+class PostmarkEmailBackend(SendMessagesMixin, AnymailPostmarkBackend):
+    def send_messages(self, email_messages):
+        if settings.WBMAILING_POSTMARK_BROADCAST_STREAM_ID:
+            for msg in email_messages:
+                if hasattr(msg, "mass_mail") and msg.mass_mail:
+                    msg.esp_extra = {"MessageStream": settings.WBMAILING_POSTMARK_BROADCAST_STREAM_ID}
+
+        return super().send_messages(email_messages)
+
+
+class SendgridEmailBackend(SendMessagesMixin, AnymailSendgridBackend):
+    pass
+
+
+class MailgunEmailBackend(SendMessagesMixin, AnymailMailgunBackend):
+    pass
+
+
+class MailjetEmailBackend(SendMessagesMixin, AnymailMailjetBackend):
+    pass
+
+
+class MandrillEmailBackend(SendMessagesMixin, AnymailMandrillBackend):
+    pass
+
+
+class SendinblueEmailBackend(SendMessagesMixin, AnymailSendinblueBackend):
+    pass
+
+
+class ConsoleEmailBackend(SendMessagesMixin, ConsoleBackend):
+    def send_messages(self, email_messages):
+        """Write all messages to the stream in a thread-safe way."""
+        if not email_messages:
+            return
+        msg_count = 0
+        with self._lock:
+            try:
+                stream_created = self.open()
+                for message in email_messages:
+                    self._process_msg(message)
+                    self.write_message(message)
+                    self.stream.flush()  # flush after each message
+                    msg_count += 1
+                if stream_created:
+                    self.close()
+            except Exception:
+                if not self.fail_silently:
+                    raise
+        return msg_count

wbmailing/dynamic_preferences_registry.py

@@ -0,0 +1,35 @@
+from re import fullmatch
+
+from django.forms import ValidationError
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import BooleanPreference, StringPreference
+
+mailing_section = Section("wbmailing")
+
+
+@global_preferences_registry.register
+class DefaultSourceMailPreference(StringPreference):
+    section = mailing_section
+    name = "default_source_mail"
+    default = "info@stainly-bench.com"
+
+    verbose_name = _("Default Source Mail Preference")
+    help_text = _("The default address used to send emails from")
+
+    def validate(self, value):
+        if not fullmatch(r"[^@]+@[^@]+\.[^@]+", value):
+            raise ValidationError(_("Not a valid email format"))
+
+
+@global_preferences_registry.register
+class AutomaticallyApproveUnsubscriptionRequestFromHardBound(BooleanPreference):
+    section = mailing_section
+    name = "automatically_approve_unsubscription_request_from_hard_bounce"
+    default = False
+
+    verbose_name = _("Automatically approve unsubscription request from hard bounce")
+    help_text = _(
+        "Automatically approve unsubscription request from hard bounce received from the ESP tracking system"
+    )

wbmailing/factories.py

@@ -0,0 +1,211 @@
+import factory
+import pytz
+from wbcore.contrib.directory.factories import EmailContactFactory
+from wbmailing.models import (
+    Mail,
+    MailEvent,
+    MailingList,
+    MailingListEmailContactThroughModel,
+    MailingListSubscriberChangeRequest,
+    MailTemplate,
+    MassMail,
+)
+
+
+class MailingListSubscriberChangeRequestFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MailingListSubscriberChangeRequest
+
+    expiration_date = factory.Faker("date_object")
+    status = MailingListSubscriberChangeRequest.Status.PENDING
+    type = MailingListSubscriberChangeRequest.Type.SUBSCRIBING
+    email_contact = factory.SubFactory("wbcore.contrib.directory.factories.EmailContactFactory")
+    mailing_list = factory.SubFactory("wbmailing.factories.MailingListFactory")
+    requester = factory.SubFactory("wbcore.contrib.authentication.factories.AuthenticatedPersonFactory")
+    approver = factory.SubFactory("wbcore.contrib.authentication.factories.AuthenticatedPersonFactory")
+    reason = factory.Faker("text", max_nb_chars=256)
+
+
+class ApprovedMailingListSubscriberChangeRequest(MailingListSubscriberChangeRequestFactory):
+    status = MailingListSubscriberChangeRequest.Status.APPROVED
+
+
+class MailingListFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MailingList
+
+    title = factory.Faker("text", max_nb_chars=64)
+    is_public = False
+
+    @factory.post_generation
+    def email_contacts(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for email_contact in extracted:
+                MailingListEmailContactThroughModel.objects.create(
+                    mailing_list=self,
+                    email_contact=email_contact,
+                    status=MailingListEmailContactThroughModel.Status.SUBSCRIBED,
+                )
+
+
+class EmailContactMailingListFactory(MailingListFactory):
+    @factory.post_generation
+    def email_contacts(self, create, extracted, **kwargs):
+        mlscr = MailingListSubscriberChangeRequestFactory()
+        self.email_contacts.add(mlscr.email_contact)
+
+
+class MailingListEmailContactFactory(EmailContactFactory):
+    @factory.post_generation
+    def subscriptions(self, create, extracted, **kwargs):
+        ml = MailingListFactory()
+        MailingListEmailContactThroughModel.objects.create(
+            mailing_list=ml, email_contact=self, status=MailingListEmailContactThroughModel.Status.SUBSCRIBED
+        )
+
+
+class UnsubscribedMailingListEmailContactFactory(EmailContactFactory):
+    @factory.post_generation
+    def subscriptions(self, create, extracted, **kwargs):
+        ml = MailingListFactory()
+        MailingListEmailContactThroughModel.objects.create(
+            mailing_list=ml, email_contact=self, status=MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        )
+
+
+class MailingListEmailContactThroughModelFactory(factory.django.DjangoModelFactory):
+    email_contact = factory.SubFactory("wbcore.contrib.directory.factories.EmailContactFactory")
+    mailing_list = factory.SubFactory("wbmailing.factories.MailingListFactory")
+    status = MailingListEmailContactThroughModel.Status.SUBSCRIBED
+
+    class Meta:
+        model = MailingListEmailContactThroughModel
+
+
+class MassMailFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MassMail
+
+    # status =  #defaut = DRAFT
+    from_email = factory.Faker("email")
+    template = factory.SubFactory("wbmailing.factories.MailTemplateFactory")
+
+    @factory.post_generation
+    def mailing_lists(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for mailing_list in extracted:
+                self.mailing_lists.add(mailing_list)
+
+    subject = factory.Faker("text", max_nb_chars=64)
+    body = factory.Faker("paragraph", nb_sentences=5)
+
+    @factory.post_generation
+    def attachments(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for attachment in extracted:
+                self.attach_document(attachment)
+
+    # body_json = #JSONField(null=True, blank=True)
+    created = factory.Faker("date_time", tzinfo=pytz.utc)
+    creator = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    send_at = factory.Faker("date_time_between", start_date="now", end_date="+30y", tzinfo=pytz.utc)
+
+
+class CustomMassMailFactory(MassMailFactory):
+    @factory.post_generation
+    def mailing_lists(self, create, extracted, **kwargs):
+        ml = MailingListFactory()
+        self.mailing_lists.add(ml)
+
+
+class CustomMassMailEmailContactFactory(EmailContactFactory):
+    @factory.post_generation
+    def subscriptions(self, create, extracted, **kwargs):
+        ml = MailingListFactory.create()
+        ml.add_to_mailinglist(self)
+        MassMailFactory.create(mailing_lists=[ml])
+
+
+class MailFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Mail
+
+    created = factory.Faker("date_time", tzinfo=pytz.utc)
+    last_send = factory.Faker("date_time", tzinfo=pytz.utc)
+    template = factory.SubFactory("wbmailing.factories.MailTemplateFactory")
+    message_ids = factory.List([factory.Faker("pystr")])
+    mass_mail = factory.SubFactory("wbmailing.factories.MassMailFactory")
+    from_email = factory.Faker("email")
+
+    @factory.post_generation
+    def to_email(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for email in extracted:
+                self.to_email.add(email)
+
+    @factory.post_generation
+    def cc_email(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for email in extracted:
+                self.cc_email.add(email)
+
+    @factory.post_generation
+    def bcc_email(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for email in extracted:
+                self.bcc_email.add(email)
+
+    subject = factory.Faker("text", max_nb_chars=64)
+    body = factory.Faker("paragraph", nb_sentences=5)
+    # body_json =  # JSONField(null=True, blank=True)
+
+    @factory.post_generation
+    def attachments(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for attachment in extracted:
+                self.attach_document(attachment)
+
+
+class ToEmailMailFactory(MailFactory):
+    @factory.post_generation
+    def to_email(self, create, extracted, **kwargs):
+        ec = EmailContactFactory.create()
+        self.to_email.add(ec)
+
+
+class MailEventFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MailEvent
+
+    mail = factory.SubFactory("wbmailing.factories.MailFactory")
+    timestamp = factory.Faker("date_time", tzinfo=pytz.utc)
+    # event_type =  # default=EventType.CREATED
+    reject_reason = ""  # default=null   # RejectReason.choices
+    description = factory.Faker("paragraph", nb_sentences=2)
+    recipient = factory.Faker("email")
+    click_url = factory.Faker("image_url")
+    ip = factory.Faker("ipv4")
+    user_agent = factory.Faker("first_name")
+    # raw_data =   JSONField(default=dict, null=True, blank=True, verbose_name="Raw Data")
+
+
+class MailTemplateFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MailTemplate
+
+    title = factory.Faker("text", max_nb_chars=64)
+    template = factory.Faker("paragraph", nb_sentences=5)

wbmailing/filters/__init__.py

@@ -0,0 +1,8 @@
+from .mailing_lists import (
+    EmailContactMailingListFilterSet,
+    MailingListEmailContactThroughModelModelFilterSet,
+    MailingListFilterSet,
+    MailingListSubscriberChangeRequestFilterSet,
+    MailStatusMassMailFilterSet,
+)
+from .mails import MailFilter, MassMailFilterSet

wbmailing/filters/mailing_lists.py

@@ -0,0 +1,84 @@
+from django.apps import apps
+from django.db.models import Exists, OuterRef
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import EmailContact, Entry
+from wbmailing import models
+
+
+class MailingListFilterSet(wb_filters.FilterSet):
+    not_factsheet_mailinglist = wb_filters.BooleanFilter(
+        label=_("No Factsheet Mailing Lists"), method="boolean_not_factsheet_mailinglist", default=True
+    )
+    negative_entry = wb_filters.ModelChoiceFilter(
+        label=_("Unsubscribed mailing lists for user"),
+        queryset=Entry.objects.all(),
+        endpoint=Entry.get_representation_endpoint(),
+        value_key=Entry.get_representation_value_key(),
+        label_key=Entry.get_representation_label_key(),
+        method="get_notsubscribed_mailing_list_for_entry",
+    )
+
+    def get_notsubscribed_mailing_list_for_entry(self, queryset, name, value):
+        if value:
+            already_subscribed_subquery = models.MailingListEmailContactThroughModel.objects.filter(
+                mailing_list=OuterRef("pk"),
+                email_contact__in=value.emails.all(),
+                status__in=[models.MailingListEmailContactThroughModel.Status.SUBSCRIBED],
+            )
+            return queryset.annotate(already_subscribed_subquery=Exists(already_subscribed_subquery)).filter(
+                already_subscribed_subquery=False
+            )
+
+        return queryset
+
+    def boolean_not_factsheet_mailinglist(self, queryset, name, value):
+        if apps.is_installed("wbreport"):
+            if value is False:
+                return queryset.filter(reports__isnull=False).distinct()
+            elif value is True:
+                return queryset.filter(reports__isnull=True).distinct()
+        return queryset
+
+    class Meta:
+        model = models.MailingList
+        fields = {"email_contacts": ["exact"], "is_public": ["exact"]}
+
+
+class MailingListSubscriberChangeRequestFilterSet(wb_filters.FilterSet):
+    class Meta:
+        model = models.MailingListSubscriberChangeRequest
+        fields = {
+            "email_contact": ["exact"],
+            "mailing_list": ["exact"],
+            "requester": ["exact"],
+            "created": ["gte", "exact", "lte"],
+        }
+
+
+class MailStatusMassMailFilterSet(wb_filters.FilterSet):
+    status = wb_filters.ChoiceFilter(label=_("Status"), choices=models.MailEvent.EventType.choices)
+
+    class Meta:
+        model = EmailContact
+        fields = {"entry": ["exact"]}
+
+
+class MailingListEmailContactThroughModelModelFilterSet(wb_filters.FilterSet):
+    expiration_date = wb_filters.DateTimeRangeFilter(
+        label=_("Expiration Date"),
+        method=wb_filters.DateRangeFilter.base_date_range_filter_method,
+    )
+    is_pending_request_change = wb_filters.BooleanFilter(
+        label=_("Pending Change"), lookup_expr="exact", field_name="is_pending_request_change"
+    )
+
+    class Meta:
+        model = models.MailingListEmailContactThroughModel
+        fields = {"status": ["exact"]}
+
+
+class EmailContactMailingListFilterSet(MailingListEmailContactThroughModelModelFilterSet):
+    class Meta:
+        model = models.MailingListEmailContactThroughModel
+        fields = {"email_contact": ["exact"], "status": ["exact"]}

wbmailing/filters/mails.py

@@ -0,0 +1,74 @@
+from django.apps import apps
+from django.utils.translation import gettext_lazy as _
+from wbcore import filters as wb_filters
+from wbmailing import models
+
+
+class MassMailFilterSet(wb_filters.FilterSet):
+    is_factsheet_massmail = wb_filters.BooleanFilter(
+        label=_("Is Factsheet Mass Mail"), method="boolean_is_factsheet_massmail", default=False
+    )
+
+    def boolean_is_factsheet_massmail(self, queryset, name, value):
+        if apps.is_installed("wbreport"):
+            if value is True:
+                return queryset.filter(mailing_lists__reports__isnull=False).distinct()
+            elif value is False:
+                return queryset.filter(mailing_lists__reports__isnull=True).distinct()
+        return queryset
+
+    class Meta:
+        model = models.MassMail
+        fields = {
+            "subject": ["exact", "icontains"],
+            "from_email": ["exact", "icontains"],
+            "template": ["exact"],
+            "mailing_lists": ["exact"],
+            "created": ["gte", "exact", "lte"],
+            "creator": ["exact"],
+            "status": ["exact"],
+        }
+
+
+class MailFilter(wb_filters.FilterSet):
+    never_open = wb_filters.BooleanFilter(label=_("Never Opened"), method="boolean_never_open")
+
+    event_type = wb_filters.MultipleChoiceFilter(
+        label=_("Events"), method="filter_events", choices=models.MailEvent.EventType.choices
+    )
+    rejected_reason = wb_filters.MultipleChoiceFilter(
+        label=_("Rejection Reasons"), method="filter_rejected_reason", choices=models.MailEvent.RejectReason.choices
+    )
+    is_massmail_mail = wb_filters.BooleanFilter(label=_("Mass Mail"), method="boolean_is_massmail")
+    status = wb_filters.ChoiceFilter(label=_("Status"), choices=models.MailEvent.EventType.choices)
+
+    class Meta:
+        model = models.Mail
+        fields = {
+            "mass_mail": ["exact"],
+            "from_email": ["exact"],
+            "to_email": ["exact"],
+            "created": ["gte", "exact", "lte"],
+        }
+
+    def boolean_is_massmail(self, queryset, name, value):
+        if value is True:
+            return queryset.filter(mass_mail__isnull=False)
+        elif value is False:
+            return queryset.filter(mass_mail__isnull=True)
+        return queryset
+
+    def boolean_never_open(self, queryset, name, value):
+        if value:
+            return queryset.exclude(events__event_type=models.MailEvent.EventType.OPENED)
+        return queryset
+
+    def filter_events(self, queryset, name, value):
+        if value:
+            return queryset.filter(events__event_type=value)
+        return queryset
+
+    def filter_rejected_reason(self, queryset, name, value):
+        if value:
+            return queryset.filter(events__reject_reason=value)
+        return queryset

wbmailing/management/__init__.py

@@ -0,0 +1,22 @@
+from django_celery_beat.models import IntervalSchedule, PeriodicTask
+from django.db import DEFAULT_DB_ALIAS
+from django.apps import apps as global_apps
+
+
+def initialize_task(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs):
+    PeriodicTask.objects.update_or_create(
+        task="wbmailing.tasks.periodic_send_mass_mail_as_tasks",
+        defaults={
+            "name": "Mailing: Periodically send scheduled mass mails",
+            "interval": IntervalSchedule.objects.get_or_create(every=120, period=IntervalSchedule.SECONDS)[0],
+            "crontab": None,
+        },
+    )
+    PeriodicTask.objects.update_or_create(
+        task="wbmailing.tasks.check_and_remove_expired_mailinglist_subscription",
+        defaults={
+            "name": "Mailing: Remove expired contact from mailing list",
+            "interval": IntervalSchedule.objects.get_or_create(every=1, period=IntervalSchedule.DAYS)[0],
+            "crontab": None,
+        },
+    )