emails: add wm api backend

Bug: T412427

Author: jsnshrmn

TWLight/emails/backends/__init__.py

@@ -0,0 +1,175 @@
+"""
+Email backend that POSTs messages to the MediaWiki Emailuser endpoint.
+see: https://www.mediawiki.org/wiki/API:Emailuser
+"""
+import logging
+import os
+from requests import Session
+from requests.structures import CaseInsensitiveDict
+from sys import stdout
+import threading
+
+from django.conf import settings
+from django.core.mail.backends.base import BaseEmailBackend
+
+from TWLight.users.models import Editor
+
+logger = logging.getLogger("django")
+
+
+class EmailBackend(BaseEmailBackend):
+    def __init__(
+        self,
+        url=None,
+        username=None,
+        password=None,
+        timeout=None,
+        rate_limit=None,
+        stream=False,
+        fail_silently=False,
+        **kwargs,
+    ):
+        super().__init__(fail_silently=fail_silently)
+        self.url = settings.MW_API_URL if url is None else url
+        self.maxlag = 5
+        self.headers = CaseInsensitiveDict()
+        self.headers["User-Agent"] = "twl mw.api.emailuser.py/0.0.1"
+        self.timeout = settings.MW_API_TIMEOUT if timeout is None else timeout
+        self.username = settings.MW_API_EMAIL_USER if username is None else username
+        self.password = settings.MW_API_EMAIL_PASSWORD if password is None else password
+        self.stream = stream or stdout
+        self.email_token = None
+        self.session = None
+        self._lock = threading.RLock()
+
+    def open(self):
+        """
+        Ensure an open session to the API server. Return whether or not a
+        new session was required (True or False) or None if an exception
+        passed silently.
+        """
+        if self.session:
+            # Nothing to do if the session exists
+            return False
+
+        try:
+            # GET request to fetch login token
+            login_token_params = {
+                "action": "query",
+                "meta": "tokens",
+                "type": "login",
+                "format": "json",
+            }
+            logger.info("Getting login token...")
+            session = Session()
+            response_login_token = session.get(url=url, params=login_token_params)
+            if response_login_token.status_code != 200:
+                raise Exception(
+                    "There was an error in the request for obtaining the login token."
+                )
+            login_token_data = response_login_token.json()
+            login_token = login_token_data["query"]["tokens"]["logintoken"]
+            if not login_token:
+                raise Exception("There was an error obtaining the login token.")
+
+            # POST request to log in. Use of main account for login is not
+            # supported. Obtain credentials via Special:BotPasswords
+            # (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
+            login_params = {
+                "action": "login",
+                "lgname": self.username,
+                "lgpassword": self.password,
+                "lgtoken": login_token,
+                "format": "json",
+            }
+            logger.info("Signing in...")
+            login_response = session.post(self.url, data=login_params)
+            if login_response.status_code != 200:
+                raise Exception("There was an error in the request for the login.")
+
+            # GET request to fetch Email token
+            email_token_params = {"action": "query", "meta": "tokens", "format": "json"}
+
+            logger.info("Getting email token...")
+            email_token_response = self.session.get(url=url, params=email_token_params)
+            email_token_data = email_token_response.json()
+
+            # Assign the session and email token
+            self.email_token = email_token_data["query"]["tokens"]["csrftoken"]
+            self.session = session
+            return True
+        except:
+            if not self.fail_silently:
+                raise
+
+    def close(self):
+        """Unset the session."""
+        self.session = None
+
+    def send_messages(self, email_messages):
+        """
+        Send one or more EmailMessage objects and return the number of email
+        messages sent.
+        """
+        if not email_messages:
+            return 0
+        with self._lock:
+            new_session_created = self.open()
+            if not self.session or new_session_created is None:
+                # We failed silently on open().
+                # Trying to send would be pointless.
+                return 0
+            num_sent = 0
+            for message in email_messages:
+                sent = self._send(message)
+                if sent:
+                    num_sent += 1
+            if new_session_created:
+                self.close()
+        return num_sent
+
+    def _send(self, email_message):
+        """A helper method that does the actual sending."""
+        if not email_message.recipients():
+            return False
+
+        try:
+            for recipient in email_message.recipients():
+                # lookup the target editor from the email address
+                target = Editor.objects.values_list("wp_username", flat=True).get(
+                    user__email=recipient
+                )
+
+                # GET request to check if user is emailable
+                emailable_params = {
+                    "action": "query",
+                    "list": "users",
+                    "ususers": target,
+                    "usprop": "emailable",
+                    "format": "json",
+                }
+
+                logger.info("Checking if user is emailable...")
+                emailable_response = session.get(url, data=emailable_params)
+                emailable_data = emailable_response.json()
+                emailable = "emailable" in emailable_data["query"]["users"][0]
+                if not emailable:
+                    continue
+
+                # POST request to send an email
+                email_params = {
+                    "action": "emailuser",
+                    "target": target,
+                    "subject": email_message.subject,
+                    "text": email_message.body,
+                    "token": self.email_token,
+                    "format": "json",
+                }
+
+                logger.info("Sending email...")
+                email_response = session.post(url, data=email_params)
+        except:
+            if not self.fail_silently:
+                raise
+            return False
+        return True