wbmailing 2.2.1__py2.py3-none-any.whl

wbmailing/tests/test_tasks.py

@@ -0,0 +1,49 @@
+from datetime import datetime, timedelta
+from unittest.mock import patch
+
+import pytest
+from django.db.models import Q
+from django.utils import timezone
+from faker import Faker
+from wbmailing.factories import MailingListSubscriberChangeRequestFactory
+from wbmailing.models import MassMail
+from wbmailing.models.mailing_lists import MailingListEmailContactThroughModel
+from wbmailing.tasks import (
+    check_and_remove_expired_mailinglist_subscription,
+    periodic_send_mass_mail_as_tasks,
+)
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestSpecificTasks:
+    @pytest.mark.parametrize("expiration_date", [fake.past_date()])
+    def test_check_and_remove_expired_mailinglist_subscription(self, expiration_date, mailing_list, email_contact):
+        request = MailingListSubscriberChangeRequestFactory(
+            expiration_date=expiration_date, email_contact=email_contact, mailing_list=mailing_list
+        )
+        request.approve()
+        request.save()
+        assert request.relationship.status == MailingListEmailContactThroughModel.Status.SUBSCRIBED
+
+        check_and_remove_expired_mailinglist_subscription()
+        request.refresh_from_db()
+        assert request.relationship.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED
+        request.refresh_from_db()
+        assert request.expiration_date is None
+
+    @patch("wbmailing.models.mails.send_mail_task.delay")
+    def test_periodic_tasks(self, send_mail_task, mass_mail_factory):
+        mass_mail_factory(status=MassMail.Status.PENDING, send_at=None)
+        send_date = timezone.now() - timedelta(minutes=15)
+        mass_mail_factory(status=MassMail.Status.SEND_LATER, send_at=send_date)
+        assert (
+            MassMail.objects.filter(Q(status=MassMail.Status.SEND_LATER) & Q(send_at__lte=datetime.now())).count() == 1
+        )
+        periodic_send_mass_mail_as_tasks()
+        send_mail_task.assert_called()
+        assert send_mail_task.call_count == 1
+        assert (
+            MassMail.objects.filter(Q(status=MassMail.Status.SEND_LATER) & Q(send_at__lte=datetime.now())).count() == 0
+        )

wbmailing/tests/test_viewsets.py

@@ -0,0 +1,216 @@
+from unittest.mock import patch
+
+import pytest
+from django.core import mail
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.directory.factories import EmailContactFactory
+from wbcore.contrib.directory.viewsets import (
+    CompanyModelViewSet,
+    EntryModelViewSet,
+    PersonModelViewSet,
+)
+from wbcore.signals.instance_buttons import add_instance_button
+from wbcore.test.utils import get_kwargs, get_model_factory
+from wbmailing.factories import (
+    CustomMassMailFactory,
+    MailEventFactory,
+    MailFactory,
+    MailingListEmailContactThroughModelFactory,
+    MailingListFactory,
+    MailingListSubscriberChangeRequestFactory,
+    MassMailFactory,
+    ToEmailMailFactory,
+)
+from wbmailing.models import (
+    MailEvent,
+    MailingListEmailContactThroughModel,
+    MailingListSubscriberChangeRequest,
+)
+from wbmailing.viewsets import (
+    EmailContactMailingListModelViewSet,
+    MailingListEntryModelViewSet,
+    MailingListSubscriberChangeRequestModelViewSet,
+    MailModelViewSet,
+    MailStatusMassMailModelViewSet,
+    ManageMailingListSubscriptions,
+    MassMailModelViewSet,
+    UnsubscribeView,
+)
+
+
+@pytest.mark.django_db
+class TestMailStatusMassMailViewSet:
+    @pytest.fixture()
+    def mass_mail(self, user):
+        email = EmailContactFactory.create()
+        ml = MailingListFactory.create(email_contacts=[email])
+        mass_mail = MassMailFactory.create(mailing_lists=[ml], status="SENT")
+        mail = MailFactory.create(mass_mail=mass_mail)
+        MailEventFactory.create(mail=mail, event_type=MailEvent.EventType.BOUNCED, recipient=email.address)
+        return mass_mail
+
+    @patch("wbmailing.models.mails.send_mail_as_task.delay")
+    @pytest.mark.parametrize("mvs", [MailStatusMassMailModelViewSet])
+    def test_resendbouncedmails(self, send_mail_as_task, mvs, mass_mail, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        kwargs = {"mass_mail_id": mass_mail.id}
+
+        response = mvs(kwargs=kwargs).resendbouncedmails(request=request, mass_mail_id=mass_mail.id)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        send_mail_as_task.assert_called()
+        assert send_mail_as_task.call_count == 1
+
+    @pytest.mark.parametrize("mvs", [MailStatusMassMailModelViewSet])
+    def test_get_custom_buttons(self, mvs, mass_mail, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        # obj = mail_factory()
+        kwargs = {"mass_mail_id": mass_mail.id}
+        mvs.kwargs = kwargs
+        response = (
+            mvs(kwargs=kwargs).button_config_class(view=mvs, request=request, instance=mass_mail).get_custom_buttons()
+        )
+        assert response
+
+
+@pytest.mark.django_db
+class TestSpecificViewsets:
+    @pytest.mark.parametrize(
+        "mvs, factory",
+        [
+            (EmailContactMailingListModelViewSet, MailingListEmailContactThroughModelFactory),
+        ],
+    )
+    def test_delete(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        response = mvs(kwargs=kwargs).delete(request=request, mailing_list_id=kwargs["mailing_list_id"], pk=obj.pk)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+
+    @pytest.mark.parametrize(
+        "mvs, factory", [(MailingListEntryModelViewSet, MailingListEmailContactThroughModelFactory)]
+    )
+    def test_delete_unsubscriber_email_contacts(self, mvs, factory, mailing_list_factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        mlscr = MailingListSubscriberChangeRequestFactory()
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        response = mvs(kwargs=kwargs).unsubscribe(
+            request=request, entry_id=mlscr.email_contact.entry.id, pk=mlscr.mailing_list.pk
+        )
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+
+    @pytest.mark.parametrize("myview", [PersonModelViewSet, CompanyModelViewSet, EntryModelViewSet])
+    def test_entry_adding_instance_buttons(self, myview, user):
+        remote_buttons = add_instance_button.send(myview, many=True)
+        custom_instance_buttons = set([button for _, button in remote_buttons])
+        assert custom_instance_buttons
+
+    # @pytest.mark.parametrize("mvs", [(MassMailModelViewSet)])
+    # def test_get_messages(self, mvs, mass_mail_factory, mail_factory, mail_event_factory, user):
+    #     request = APIRequestFactory().get("")
+    #     request.user = user
+    #     obj = mass_mail_factory(status = MassMail.Status.SENT)
+    #     qs = mvs().get_queryset()
+    #     mail = mail_factory(mass_mail=qs[0])
+    #     me = mail_event_factory(mail = mail, event_type=MailEvent.EventType.CLICKED)
+
+    #     msg = mvs().get_messages(request, instance=qs[0])
+    #     assert msg
+
+    @pytest.mark.parametrize("mvs, factory", [(MassMailModelViewSet, CustomMassMailFactory)])
+    def test_sendtestmail(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        obj = factory()
+        EmailContactFactory(address=request.user.email)
+        # request.POST = request.POST.copy()
+        # request.POST['to_test_email'] = "lemissan@atonra.ch"
+        nb_mail_send = len(mail.outbox)
+        request.query_params = {}
+        mvs.request = request
+        mvs.kwargs = get_kwargs(obj, mvs, request)
+        mvs.kwargs["pk"] = obj.pk
+        response = mvs().sendtestmail(request)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert len(mail.outbox) == nb_mail_send + 1
+
+    @pytest.mark.parametrize("mvs, factory", [(MailModelViewSet, ToEmailMailFactory)])
+    def test_get_queryset_mail(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        request.user.is_superuser = False
+        request.user.save()
+        obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        vs = mvs.as_view({"get": "list"})
+        response = vs(request, **kwargs)
+        assert response.status_code == status.HTTP_403_FORBIDDEN
+
+    @patch("wbmailing.models.mails.send_mail_as_task.delay")
+    def test_resend(self, send_mail_as_task, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        obj = ToEmailMailFactory()
+        request.query_params = {}
+        MailModelViewSet.request = request
+        MailModelViewSet.kwargs = get_kwargs(obj, MailModelViewSet, request)
+        MailModelViewSet.kwargs["pk"] = obj.pk
+        response = MailModelViewSet().resend(request)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        send_mail_as_task.assert_called()
+        assert send_mail_as_task.call_count == 1
+
+    @pytest.mark.parametrize("user__is_superuser", [True])
+    def test_get_custom_buttons_approveall(self, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        factory = get_model_factory(MailingListSubscriberChangeRequestModelViewSet().get_serializer_class().Meta.model)
+        for i in range(2):
+            obj = factory()
+        kwargs = get_kwargs(obj, MailingListSubscriberChangeRequestModelViewSet, request)
+        assert (
+            MailingListSubscriberChangeRequest.objects.filter(
+                status=MailingListSubscriberChangeRequest.Status.PENDING
+            ).count()
+            == 2
+        )
+        response = (
+            MailingListSubscriberChangeRequestModelViewSet(kwargs=kwargs)
+            .button_config_class(view=MailingListSubscriberChangeRequestModelViewSet, request=request, instance=obj)
+            .get_custom_buttons()
+        )
+        assert response
+
+    @pytest.mark.parametrize(
+        "mvs, factory", [(ManageMailingListSubscriptions, MailingListEmailContactThroughModelFactory)]
+    )
+    def test_ManageMailingListSubscriptions(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        through_model = factory()
+        response = mvs().get(request, through_model.email_contact.id)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.content
+
+    @pytest.mark.parametrize("mvs, factory", [(UnsubscribeView, MailingListEmailContactThroughModelFactory)])
+    def test_UnsubscribeView(self, mvs, factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        through_model = factory()
+        mailing_list = through_model.mailing_list
+        response = mvs().get(request, through_model.email_contact.id, mailing_list.id)
+        assert response.status_code == status.HTTP_302_FOUND
+        assert response.url
+        through_model.refresh_from_db()
+        assert through_model.status == MailingListEmailContactThroughModel.Status.UNSUBSCRIBED

wbmailing/tests/tests.py

@@ -0,0 +1,142 @@
+from unittest.mock import patch
+
+import pytest
+from django.contrib.admin import AdminSite
+from django.core import mail
+from django.forms.models import model_to_dict
+from django.template import Context, Template
+from rest_framework import status
+from rest_framework.serializers import ValidationError
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.directory.factories import EmailContactFactory
+from wbcore.test import GenerateTest, default_config
+from wbcore.test.utils import get_kwargs, get_model_factory
+from wbmailing.admin import MailAdmin, MassMailAdmin
+from wbmailing.factories import ToEmailMailFactory
+from wbmailing.models import Mail, MailingListSubscriberChangeRequest, MassMail
+from wbmailing.models.mails import send_mail_as_task
+from wbmailing.serializers import MailingListSubscriberChangeRequestModelSerializer
+from wbmailing.templatetags.mailing_tags import strip, stripAndsplit
+from wbmailing.viewsets import MailingListSubscriberChangeRequestModelViewSet
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbmailing")
+            and x.__name__
+            not in [
+                "ClientsBarChartViewSet",
+                "CountryBarChartViewSet",
+                "RegionBarChartViewSet",
+                "MailStatusBarChartViewSet",
+                "MailClickBarChartViewSet",
+                "AbstractRawDataChartViewSet",
+            ],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass
+
+
+@pytest.mark.django_db
+class TestSpecificAdmin:
+    def test_send_test_mail(self, mass_mail_factory, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        EmailContactFactory(address=request.user.email)
+        mass_mail_factory()
+        qs = MassMail.objects.all()
+        mma = MassMailAdmin(MassMail, AdminSite())
+        nb_mail_send = len(mail.outbox)
+        mma.send_test_mail(request, qs)
+        assert len(mail.outbox) == nb_mail_send + 1
+
+    @patch("wbmailing.models.mails.send_mail_as_task.delay")
+    def test_MailAdmin(self, send_mail_as_task, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        ToEmailMailFactory()
+        qs = Mail.objects.all()
+
+        ma = MailAdmin(Mail, AdminSite())
+        ma.send_mails(request, qs)
+        send_mail_as_task.assert_called()
+        assert send_mail_as_task.call_count == 1
+
+    def test_send_mail_as_task(self):
+        obj = ToEmailMailFactory.create()
+        context = {}
+        if obj.to_email.count() == 1:
+            context = {"salutation": obj.to_email.first().entry.salutation}
+        rendered_subject = Template(obj.subject).render(Context(context))
+        msg = {
+            "subject": rendered_subject,
+            "body": obj.body,
+            "from_email": obj.from_email,
+            "to": list(obj.to_email.values_list("address", flat=True)),
+            "bcc": list(obj.bcc_email.values_list("address", flat=True)),
+            "cc": list(obj.cc_email.values_list("address", flat=True)),
+            "mail_id": obj.id,
+        }
+        if obj.mass_mail:
+            msg["mass_mail_id"] = obj.mass_mail.id
+        assert len(mail.outbox) == 0
+        send_mail_as_task(**msg)
+        assert len(mail.outbox) == 1
+
+    def test_stripAndsplit(self):
+        string = "diego loic is the best man"
+        result = stripAndsplit(string, " ")
+        assert len(result) == 6
+
+    def test_strip(self):
+        string = "diego/loic/is/the/best/man"
+        string = strip(string)
+        result = stripAndsplit(string, " ")
+        assert len(result) == 1
+
+    def test_validate_email_contact(self, mailing_list, mailing_list_subscriber_change_request_factory, user):
+        request = APIRequestFactory().post("")
+        request.user = user
+        request.parser_context = {}
+        request.data = {"crm_profile": request.user.profile.id}
+        serializer = MailingListSubscriberChangeRequestModelSerializer(
+            mailing_list_subscriber_change_request_factory(mailing_list=mailing_list), context={"request": request}
+        )
+        data = model_to_dict(mailing_list_subscriber_change_request_factory.build(mailing_list=mailing_list))
+        del data["email_contact"]
+        assert serializer.validate(data)  # this is fine because the instance is still in the serializer
+
+        serializer = MailingListSubscriberChangeRequestModelSerializer(context={"request": request})
+        with pytest.raises((ValidationError)):
+            serializer.validate(data)
+
+    @pytest.mark.parametrize("mvs", [MailingListSubscriberChangeRequestModelViewSet])
+    def test_approveall(self, mvs, user):
+        request = APIRequestFactory().get("")
+        request.user = user
+        factory = get_model_factory(mvs().get_serializer_class().Meta.model)
+        for i in range(2):
+            obj = factory()
+        kwargs = get_kwargs(obj, mvs, request)
+        assert (
+            MailingListSubscriberChangeRequest.objects.filter(
+                status=MailingListSubscriberChangeRequest.Status.PENDING
+            ).count()
+            == 2
+        )
+        response = mvs(kwargs=kwargs).approveall(request=request)
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert (
+            MailingListSubscriberChangeRequest.objects.filter(
+                status=MailingListSubscriberChangeRequest.Status.APPROVED
+            ).count()
+            == 2
+        )

wbmailing/urls.py

@@ -0,0 +1,90 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbmailing import viewsets
+
+router = WBCoreRouter()
+router.register(r"mailinglist", viewsets.MailingListModelViewSet)
+router.register(r"mailrepresentation", viewsets.MailRepresentationViewSet, basename="mailrepresentation")
+router.register(
+    r"mailinglistrepresentation", viewsets.MailingListRepresentationViewSet, basename="mailinglistrepresentation"
+)
+router.register(
+    r"mailtemplaterepresentation", viewsets.MailTemplateRepresentationViewSet, basename="mailtemplaterepresentation"
+)
+router.register(r"massmailrepresentation", viewsets.MassMailRepresentationViewSet, basename="massmailrepresentation")
+
+
+router.register(r"massmail", viewsets.MassMailModelViewSet)
+router.register(r"mailevent", viewsets.MailEventModelViewSet)
+router.register(r"mail", viewsets.MailModelViewSet)
+router.register(r"mailtemplate", viewsets.MailTemplateModelViewSet)
+router.register(
+    r"mailinglistsubscriberchangerequest",
+    viewsets.MailingListSubscriberChangeRequestModelViewSet,
+    basename="mailinglistsubscriberchangerequest",
+)
+router.register(
+    "mailinglistemailcontact",
+    viewsets.MailingListEmailContactThroughModelModelViewSet,
+    basename="mailinglistemailcontact",
+)
+
+entry_router = WBCoreRouter()
+entry_router.register(r"mailinglist", viewsets.MailingListEntryModelViewSet, basename="entry-mailinglist")
+
+
+entry_router.register(
+    r"mailinglistsubscriberchangerequest",
+    viewsets.MailingListSubscriberRequestEntryModelViewSet,
+    basename="entry-mailinglistsubscriberchangerequest",
+)
+
+mailinglist_router = WBCoreRouter()
+mailinglist_router.register(
+    r"mailinglistsubscriberchangerequest",
+    viewsets.MailingListSubscriberRequestMailingListModelViewSet,
+    basename="mailing_list-mailinglistsubscriberchangerequest",
+)
+mailinglist_router.register(
+    r"email_contacts",
+    viewsets.EmailContactMailingListModelViewSet,
+    basename="mailing_list-email_contacts",
+)
+mailinglist_router.register(
+    r"maileventchart", viewsets.MailMailingListChartViewSet, basename="mailing_list-maileventchart"
+)
+
+
+mail_router = WBCoreRouter()
+mail_router.register(r"mailevent", viewsets.MailEventMailModelViewSet, basename="mail-mailevent")
+
+massmail_router = WBCoreRouter()
+massmail_router.register(r"mailstatus", viewsets.MailStatusMassMailModelViewSet, basename="massmail-mailstatus")
+massmail_router.register(
+    r"mailstatusbarchart", viewsets.MailStatusBarChartViewSet, basename="massmail-mailstatusbarchart"
+)
+massmail_router.register(
+    r"mailclickbarchart", viewsets.MailClickBarChartViewSet, basename="massmail-mailclickbarchart"
+)
+massmail_router.register(r"clientsbarchart", viewsets.ClientsBarChartViewSet, basename="massmail-clientsbarchart")
+massmail_router.register(r"countrybarchart", viewsets.CountryBarChartViewSet, basename="massmail-countrybarchart")
+massmail_router.register(r"regionbarchart", viewsets.RegionBarChartViewSet, basename="massmail-regionbarchart")
+massmail_router.register("mailevent", viewsets.MailEventMassMailMailModelViewSet, basename="massmail-mailevent")
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("entry/<int:entry_id>/", include(entry_router.urls)),
+    path("mailing_list/<int:mailing_list_id>/", include(mailinglist_router.urls)),
+    path("mail/<int:mail_id>/", include(mail_router.urls)),
+    path("massmail/<int:mass_mail_id>/", include(massmail_router.urls)),
+    path(
+        "manage_mailing_list_subscriptions/<int:email_contact_id>/",
+        viewsets.ManageMailingListSubscriptions.as_view(),
+        name="manage_mailing_list_subscriptions",
+    ),
+    path(
+        "unsubscribe/<int:email_contact_id>/<int:mailing_list_id>/",
+        viewsets.UnsubscribeView.as_view(),
+        name="unsubscribe",
+    ),
+]

wbmailing/viewsets/__init__.py

@@ -0,0 +1,32 @@
+from .analytics import (
+    ClientsBarChartViewSet,
+    CountryBarChartViewSet,
+    MailClickBarChartViewSet,
+    MailStatusBarChartViewSet,
+    RegionBarChartViewSet,
+)
+from .mailing_lists import (
+    EmailContactMailingListModelViewSet,
+    MailingListEmailContactThroughModelModelViewSet,
+    MailingListEntryModelViewSet,
+    MailingListModelViewSet,
+    MailingListRepresentationViewSet,
+    MailingListSubscriberChangeRequestModelViewSet,
+    MailingListSubscriberRequestEntryModelViewSet,
+    MailingListSubscriberRequestMailingListModelViewSet,
+    ManageMailingListSubscriptions,
+    UnsubscribeView,
+)
+from .mails import (
+    MailEventModelViewSet,
+    MailEventMailModelViewSet,
+    MailEventMassMailMailModelViewSet,
+    MailMailingListChartViewSet,
+    MailModelViewSet,
+    MailRepresentationViewSet,
+    MailStatusMassMailModelViewSet,
+    MailTemplateModelViewSet,
+    MailTemplateRepresentationViewSet,
+    MassMailModelViewSet,
+    MassMailRepresentationViewSet,
+)

wbmailing/viewsets/analytics.py

@@ -0,0 +1,110 @@
+from typing import TYPE_CHECKING
+
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from django.db.models import QuerySet
+from wbcore import viewsets
+from wbmailing.models import Mail, MailEvent
+
+if TYPE_CHECKING:
+    from plotly.graph_objs._figure import Figure
+
+
+class MailStatusBarChartViewSet(viewsets.ChartViewSet):
+    IDENTIFIER = "wbmailing:mailstatus-barchart"
+    queryset = MailEvent.objects.all()
+
+    def get_queryset(self) -> QuerySet[Mail]:
+        mass_mail_id = self.kwargs["mass_mail_id"]
+
+        return super().get_queryset().filter(mail__mass_mail_id=mass_mail_id)
+
+    def get_plotly(self, queryset: QuerySet[Mail]) -> "Figure":
+        df = pd.DataFrame(queryset.values("event_type"))
+        df["count"] = 1
+
+        df = df.groupby(["event_type"])["count"].count().reset_index().sort_values(by="count")
+        fig = px.bar(df, x="count", y="event_type", orientation="h")
+        fig.update_layout(
+            yaxis={"showticklabels": True, "title": None},
+            xaxis={"title": "Number"},
+            title={"text": "Mail Status", "x": 0.5},
+        )
+        return fig
+
+
+class MailClickBarChartViewSet(viewsets.ChartViewSet):
+    IDENTIFIER = "wbmailing:mailclick-barchart"
+    queryset = MailEvent.objects.all()
+
+    def get_queryset(self) -> QuerySet[MailEvent]:
+        mass_mail_id = self.kwargs["mass_mail_id"]
+
+        return super().get_queryset().filter(mail__mass_mail_id=mass_mail_id, event_type=MailEvent.EventType.CLICKED)
+
+    def get_plotly(self, queryset: QuerySet[MailEvent]) -> "Figure":
+        df = pd.DataFrame(queryset.values("click_url"))
+        df["count"] = 1
+        df = df.groupby(["click_url"])["count"].count().reset_index().sort_values(by="count")
+        fig = go.Figure(layout=dict(template="plotly"))  # noqa THis is necessary to prevent some racing condition
+        fig = px.bar(df, x="count", y="click_url", text="click_url", orientation="h")
+        fig.update_layout(
+            yaxis={"visible": False, "showticklabels": False},
+            xaxis={"title": "Number of clicks"},
+            title={"text": "Clicked URLs", "x": 0.5},
+        )
+        return fig
+
+
+class AbstractRawDataChartViewSet(viewsets.ChartViewSet):
+    queryset = MailEvent.objects.all()
+    ANALYTICS_PROPERTY: str
+
+    def get_queryset(self) -> QuerySet[MailEvent]:
+        mass_mail_id = self.kwargs["mass_mail_id"]
+
+        return super().get_queryset().filter(mail__mass_mail_id=mass_mail_id, event_type=MailEvent.EventType.OPENED)
+
+    def get_plotly(self, queryset: QuerySet[MailEvent]) -> "Figure":
+        df = pd.DataFrame(queryset.values(self.ANALYTICS_PROPERTY))
+        df["count"] = 1
+        df = df.groupby(self.ANALYTICS_PROPERTY)["count"].count().reset_index().sort_values(by="count")
+        fig = go.Figure()
+        if not df.empty:
+            fig = px.bar(df, x=self.ANALYTICS_PROPERTY, y="count")
+            fig.update_layout(
+                xaxis={"showticklabels": True, "title": None},
+                yaxis={"showticklabels": True, "title": "Number"},
+            )
+        return fig
+
+
+class ClientsBarChartViewSet(AbstractRawDataChartViewSet):
+    IDENTIFIER = "wbmailing:client-barchart"
+    ANALYTICS_PROPERTY = "raw_data__Client__Name"
+
+    def get_plotly(self, queryset: QuerySet[MailEvent]) -> "Figure":
+        fig = super().get_plotly(queryset)
+        fig.update_layout(title={"text": "Platforms", "x": 0.5})
+        return fig
+
+
+class CountryBarChartViewSet(AbstractRawDataChartViewSet):
+    IDENTIFIER = "wbmailing:country-barchart"
+    ANALYTICS_PROPERTY = "raw_data__Geo__Country"
+
+    def get_plotly(self, queryset: QuerySet[MailEvent]) -> "Figure":
+        fig = super().get_plotly(queryset)
+        fig.update_layout(title={"text": "Countries", "x": 0.5})
+        return fig
+
+
+class RegionBarChartViewSet(AbstractRawDataChartViewSet):
+    IDENTIFIER = "wbmailing:region-barchart"
+    ANALYTICS_PROPERTY = "raw_data__Geo__Region"
+
+    def get_plotly(self, queryset: QuerySet[MailEvent]) -> "Figure":
+        fig = super().get_plotly(queryset)
+        fig.update_layout(title={"text": "Regions", "x": 0.5})
+        return fig

wbmailing/viewsets/buttons/__init__.py

@@ -0,0 +1,10 @@
+from .mailing_lists import (
+    MailingListButtonConfig,
+    MailingListEmailContactThroughModelButtonConfig,
+    MailingListSubcriptionRequestButtonConfig,
+)
+from .mails import (
+    MailButtonConfig,
+    MailStatusMassMailButtonConfig,
+    MassMailButtonConfig,
+)