# -*- coding: utf-8 -*- # # Copyright (C) 2016-2023 by the Free Software Foundation, Inc. # # This file is part of Django-Mailman. # # Django-Mailman is free software: you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) # any later version. # # Django-Mailman is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for # more details. # # You should have received a copy of the GNU General Public License along with # Django-Mailman. If not, see . # # Author: Aurelien Bompard # import logging from urllib.error import HTTPError from django.conf import settings from django.core.cache import cache from django.db import IntegrityError from allauth.account.models import EmailAddress from mailmanclient import Client as MailmanClient from mailmanclient import MailmanConnectionError logger = logging.getLogger(__name__) _REQUEST_HOOKS = [] #: List of hooks that can into request parameter of Mailmanclient. def mailmanclient_request_hook(fn): """Decorator that converts a method into Mailmanclient request hook.""" if fn not in _REQUEST_HOOKS: _REQUEST_HOOKS.append(fn) return fn def get_request_hooks(): """Get a list of default request hooks. Returns default hooks, but only in DEBUG mode. """ return _REQUEST_HOOKS def get_mailman_client(api_version='3.1'): """Return an instance of Mailman Client. :param api_version: The API version for Mailman Core to use. :type api_version: string :returns: An instance of :class:`mailmanclient.Client` """ # easier to patch during unit tests client = MailmanClient( '{}/{}'.format(settings.MAILMAN_REST_API_URL, api_version), settings.MAILMAN_REST_API_USER, settings.MAILMAN_REST_API_PASS, get_request_hooks()) return client def get_mailman_user(user): """Given a Django user, return the Mailman's user object. If the user does not exist, we will try to create one. If neither of the get or create options work, perhaps because API is un-reachable, we return a None value. :param user: Instance of a Django user. :returns: Mailman user or None if Mailman API isn't available. :rtype: :class:`mailmanclient.User` """ # Only cache the mailman user_id, not the whole user instance, because # mailmanclient is not pickle-safe cache_key = "User:%s:mailman_user_id" % user.id mm_user_id = cache.get(cache_key) try: mm_client = get_mailman_client() mm_user = None if mm_user_id is not None: # Due upgrade from Mailman API 3.0 to 3.1, integer user_id can # return 404 if the API version used was 3.1 (which has user_ids as # UUIDs). So, we are going to lookup with email if the cached # user_id returns 404. try: mm_user = mm_client.get_user(mm_user_id) except HTTPError as e: if e.code != 404: raise # So, either the user_id wasn't cached or the cached user_id didn't # return a valid user. Now lookup with user's email. if mm_user is None: try: mm_user = mm_client.get_user(user.email) except HTTPError as e: if e.code != 404: raise # will be caught down there mm_user = mm_client.create_user( user.email, user.get_full_name()) # XXX The email is not set as verified, because we don't # know if the registration that was used verified it. logger.info("Created Mailman user for %s (%s)", user.username, user.email) # Update the cache to avoid a lookup next time. cache.set(cache_key, mm_user.user_id, None) return mm_user except (HTTPError, MailmanConnectionError) as e: logger.warning( "Error getting or creating the Mailman user of %s (%s): %s", user.username, user.email, e) return None def get_mailman_user_id(user): # TODO: Optimization: look in the cache first, if not found call # get_mailman_user() as before mm_user = get_mailman_user(user) if mm_user is None: return None return str(mm_user.user_id) def get_subscriptions(user): # Get subscriptions for the provided Django user. def _get_value(): mm_user = get_mailman_user(user) if mm_user is None: return {} subscriptions = dict([ (member.list_id, member.address) for member in mm_user.subscriptions if member.role != "nonmember" ]) return subscriptions # TODO: how should this be invalidated? Subscribe to a signal in # mailman when a new subscription occurs? Or store in the session? return cache.get_or_set( "User:%s:subscriptions" % user.id, _get_value, 60, version=2) # 1 minute # TODO: increase the cache duration when we have Mailman signals def add_address_to_mailman_user(user, address): """Associate a verified address with a Mailman user.""" logger.debug("Associating address %s with user %s in Mailman", address, user.username) mm_user = get_mailman_user(user) if mm_user is None: logger.info("Could not find or create a Mailman user for %s", user.username) return existing_addresses = [str(addr) for addr in mm_user.addresses] if address not in existing_addresses: # Associate it with the user. try: mm_address = mm_user.add_address(address, absorb_existing=True) mm_address.verify() logger.debug("Associated address %s with %s", address, user.username) except HTTPError as e: logger.warning("Can't add %s to %s: %s", address, user.username, e) else: # Already associated, just mark it verified. mm_address = get_mailman_client().get_address(address) if mm_address.verified_on is None: mm_address.verify() def sync_email_addresses(user): # Synchronize email addresses for the user in Mailman and in Django. When # an address is missing, it is added, no deletion is performed here. # For deletion, use the appropriate view/form. The 'verified' bit is also # sychronized. logger.debug("Synchronizing email addresses for user %s", user.username) mm_user = get_mailman_user(user) if mm_user is None: logger.info("Could not find or create a Mailman user for %s", user.username) return def check_verified(django_address, mm_address): if mm_address.verified and not django_address.verified: django_address.verified = True django_address.save() if django_address.verified and not mm_address.verified: mm_address.verify() django_addresses = EmailAddress.objects.filter(user=user).all() mailman_addresses = mm_user.addresses # Django for django_address in django_addresses: mm_address = mailman_addresses.find_by_email(django_address.email) if mm_address is not None: check_verified(django_address, mm_address) else: mm_address = mm_user.add_address( django_address.email, absorb_existing=True) if django_address.verified: mm_address.verify() # Mailman for mm_address in mailman_addresses: if not mm_address.verified: continue try: django_address, _created = EmailAddress.objects.get_or_create( user=user, email=mm_address.email) except IntegrityError: continue # Email exists and belongs to another user. check_verified(django_address, mm_address) def update_preferred_address(user, to_email_address): """Update the preferred address of a user in Mailman Core. This synchronizes the preferred address between Mailman Core and Django, although, it is a one-way sync. """ logger.debug("Synchronizing primary address for user %s", user.username) mm_user = get_mailman_user(user) if mm_user is None: logger.info( "Could not find or create a Mailman user for %s", user.username) return if not to_email_address.verified: return # Note: Although, setting preferred address will already add the address to # the user, but if the address isn't verified then it will result in an # exception. So, we trigger a verify + add workflow before setting primary # address. add_address_to_mailman_user(user, to_email_address.email) # Finally, set the preferred address. try: mm_user.preferred_address = to_email_address.email except HTTPError: logger.error("Failed to update preferred address for %s in Core", user.username, exc_info=True)