src/mailman/model/roster.py

   1 # Copyright (C) 2007-2015 by the Free Software Foundation, Inc.
   2 #
   3 # This file is part of GNU Mailman.
   4 #
   5 # GNU Mailman is free software: you can redistribute it and/or modify it under
   6 # the terms of the GNU General Public License as published by the Free
   7 # Software Foundation, either version 3 of the License, or (at your option)
   8 # any later version.
   9 #
  10 # GNU Mailman is distributed in the hope that it will be useful, but WITHOUT
  11 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 # more details.
  14 #
  15 # You should have received a copy of the GNU General Public License along with
  16 # GNU Mailman.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 """An implementation of an IRoster.
  19
  20 These are hard-coded rosters which know how to filter a set of members to find
  21 the ones that fit a particular role.  These are used as the member, owner,
  22 moderator, and administrator roster filters.
  23 """
  24
  25 __all__ = [
  26     'AdministratorRoster',
  27     'DigestMemberRoster',
  28     'MemberRoster',
  29     'Memberships',
  30     'ModeratorRoster',
  31     'OwnerRoster',
  32     'RegularMemberRoster',
  33     'Subscribers',
  34     ]
  35
  36
  37 from mailman.database.transaction import dbconnection
  38 from mailman.interfaces.member import DeliveryMode, MemberRole
  39 from mailman.interfaces.roster import IRoster
  40 from mailman.model.address import Address
  41 from mailman.model.member import Member
  42 from sqlalchemy import and_, or_
  43 from zope.interface import implementer
  44
  45
  46 \f
  47 @implementer(IRoster)
  48 class AbstractRoster:
  49     """An abstract IRoster class.
  50
  51     This class takes the simple approach of implemented the 'users' and
  52     'addresses' properties in terms of the 'members' property.  This may not
  53     be the most efficient way, but it works.
  54
  55     This requires that subclasses implement the 'members' property.
  56     """
  57     role = None
  58
  59     def __init__(self, mlist):
  60         self._mlist = mlist
  61
  62     @dbconnection
  63     def _query(self, store):
  64         return store.query(Member).filter(
  65             Member.list_id == self._mlist.list_id,
  66             Member.role == self.role)
  67
  68     @property
  69     def members(self):
  70         """See `IRoster`."""
  71         for member in self._query():
  72             yield member
  73
  74     @property
  75     def member_count(self):
  76         """See `IRoster`."""
  77         return self._query().count()
  78
  79     @property
  80     def users(self):
  81         """See `IRoster`."""
  82         # Members are linked to addresses, which in turn are linked to users.
  83         # So while the 'members' attribute does most of the work, we have to
  84         # keep a set of unique users.  It's possible for the same user to be
  85         # subscribed to a mailing list multiple times with different
  86         # addresses.
  87         users = set(member.address.user for member in self.members)
  88         for user in users:
  89             yield user
  90
  91     @property
  92     def addresses(self):
  93         """See `IRoster`."""
  94         # Every Member is linked to exactly one address so the 'members'
  95         # attribute does most of the work.
  96         for member in self.members:
  97             yield member.address
  98
  99     @dbconnection
 100     def get_member(self, store, email):
 101         """See `IRoster`."""
 102         results = self._query().filter(
 103             Address.email == email,
 104             Member.address_id == Address.id)
 105         if results.count() == 0:
 106             return None
 107         elif results.count() == 1:
 108             return results[0]
 109         else:
 110             raise AssertionError(
 111                 'Too many matching member results: {0}'.format(
 112                     results.count()))
 113
 114
 115 \f
 116 class MemberRoster(AbstractRoster):
 117     """Return all the members of a list."""
 118
 119     name = 'member'
 120     role = MemberRole.member
 121
 122
 123 \f
 124 class NonmemberRoster(AbstractRoster):
 125     """Return all the nonmembers of a list."""
 126
 127     name = 'nonmember'
 128     role = MemberRole.nonmember
 129
 130
 131 \f
 132 class OwnerRoster(AbstractRoster):
 133     """Return all the owners of a list."""
 134
 135     name = 'owner'
 136     role = MemberRole.owner
 137
 138
 139 \f
 140 class ModeratorRoster(AbstractRoster):
 141     """Return all the owners of a list."""
 142
 143     name = 'moderator'
 144     role = MemberRole.moderator
 145
 146
 147 \f
 148 class AdministratorRoster(AbstractRoster):
 149     """Return all the administrators of a list."""
 150
 151     name = 'administrator'
 152
 153     @dbconnection
 154     def _query(self, store):
 155         return store.query(Member).filter(
 156             Member.list_id == self._mlist.list_id,
 157             or_(Member.role == MemberRole.owner,
 158                 Member.role == MemberRole.moderator))
 159
 160     @dbconnection
 161     def get_member(self, store, email):
 162         """See `IRoster`."""
 163         results = store.query(Member).filter(
 164             Member.list_id == self._mlist.list_id,
 165             or_(Member.role == MemberRole.moderator,
 166                 Member.role == MemberRole.owner),
 167             Address.email == email,
 168             Member.address_id == Address.id)
 169         if results.count() == 0:
 170             return None
 171         elif results.count() == 1:
 172             return results[0]
 173         else:
 174             raise AssertionError(
 175                 'Too many matching member results: {0}'.format(results))
 176
 177
 178 \f
 179 class DeliveryMemberRoster(AbstractRoster):
 180     """Return all the members having a particular kind of delivery."""
 181
 182     role = MemberRole.member
 183
 184     @property
 185     def member_count(self):
 186         """See `IRoster`."""
 187         # XXX 2012-03-15 BAW: It would be nice to make this more efficient.
 188         # The problem is that you'd have to change the loop in _get_members()
 189         # checking the delivery mode to a query parameter.
 190         return len(tuple(self.members))
 191
 192     @dbconnection
 193     def _get_members(self, store, *delivery_modes):
 194         """The set of members for a mailing list, filter by delivery mode.
 195
 196         :param delivery_modes: The modes to filter on.
 197         :type delivery_modes: sequence of `DeliveryMode`.
 198         :return: A generator of members.
 199         :rtype: generator
 200         """
 201         results = store.query(Member).filter_by(
 202             list_id = self._mlist.list_id,
 203             role = MemberRole.member)
 204         for member in results:
 205             if member.delivery_mode in delivery_modes:
 206                 yield member
 207
 208
 209 class RegularMemberRoster(DeliveryMemberRoster):
 210     """Return all the regular delivery members of a list."""
 211
 212     name = 'regular_members'
 213
 214     @property
 215     def members(self):
 216         """See `IRoster`."""
 217         for member in self._get_members(DeliveryMode.regular):
 218             yield member
 219
 220
 221 \f
 222 class DigestMemberRoster(DeliveryMemberRoster):
 223     """Return all the regular delivery members of a list."""
 224
 225     name = 'digest_members'
 226
 227     @property
 228     def members(self):
 229         """See `IRoster`."""
 230         for member in self._get_members(DeliveryMode.plaintext_digests,
 231                                         DeliveryMode.mime_digests,
 232                                         DeliveryMode.summary_digests):
 233             yield member
 234
 235
 236 \f
 237 class Subscribers(AbstractRoster):
 238     """Return all subscribed members regardless of their role."""
 239
 240     name = 'subscribers'
 241
 242     @dbconnection
 243     def _query(self, store):
 244         return store.query(Member).filter_by(list_id = self._mlist.list_id)
 245
 246
 247 \f
 248 @implementer(IRoster)
 249 class Memberships:
 250     """A roster of a single user's memberships."""
 251
 252     name = 'memberships'
 253
 254     def __init__(self, user):
 255         self._user = user
 256
 257     @dbconnection
 258     def _query(self, store):
 259         results = store.query(Member).filter(
 260             or_(Member.user_id == self._user.id,
 261             and_(Address.user_id == self._user.id,
 262                  Member.address_id == Address.id)))
 263         return results.distinct()
 264
 265     @property
 266     def member_count(self):
 267         """See `IRoster`."""
 268         return self._query().count()
 269
 270     @property
 271     def members(self):
 272         """See `IRoster`."""
 273         for member in self._query():
 274             yield member
 275
 276     @property
 277     def users(self):
 278         """See `IRoster`."""
 279         yield self._user
 280
 281     @property
 282     def addresses(self):
 283         """See `IRoster`."""
 284         for address in self._user.addresses:
 285             yield address
 286
 287     @dbconnection
 288     def get_member(self, store, email):
 289         """See `IRoster`."""
 290         results = store.query(Member).filter(
 291             Member.address_id == Address.id,
 292             Address.user_id == self._user.id)
 293         if results.count() == 0:
 294             return None
 295         elif results.count() == 1:
 296             return results[0]
 297         else:
 298             raise AssertionError(
 299                 'Too many matching member results: {0}'.format(
 300                     results.count()))