# -*- 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)