1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
# Copyright (C) 2007 by the Free Software Foundation, Inc.
#
# This program 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 2
# of the License, or (at your option) any later version.
#
# This program 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 this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
# USA.
"""An implementation of an IRoster.
These are hard-coded rosters which know how to filter a set of members to find
the ones that fit a particular role. These are used as the member, owner,
moderator, and administrator roster filters.
"""
from storm.locals import *
from zope.interface import implements
from Mailman.configuration import config
from Mailman.constants import SystemDefaultPreferences
from Mailman.database.address import Address
from Mailman.database.member import Member
from Mailman.interfaces import DeliveryMode, IRoster, MemberRole
class AbstractRoster(object):
"""An abstract IRoster class.
This class takes the simple approach of implemented the 'users' and
'addresses' properties in terms of the 'members' property. This may not
be the most efficient way, but it works.
This requires that subclasses implement the 'members' property.
"""
implements(IRoster)
role = None
def __init__(self, mlist):
self._mlist = mlist
@property
def members(self):
for member in config.db.store.find(
Member,
mailing_list=self._mlist.fqdn_listname,
role=self.role):
yield member
@property
def users(self):
# Members are linked to addresses, which in turn are linked to users.
# So while the 'members' attribute does most of the work, we have to
# keep a set of unique users. It's possible for the same user to be
# subscribed to a mailing list multiple times with different
# addresses.
users = set(member.address.user for member in self.members)
for user in users:
yield user
@property
def addresses(self):
# Every Member is linked to exactly one address so the 'members'
# attribute does most of the work.
for member in self.members:
yield member.address
def get_member(self, address):
results = config.db.store.find(
Member,
Member.mailing_list == self._mlist.fqdn_listname,
Member.role == self.role,
Address.address == address,
Member.address_id == Address.id)
if results.count() == 0:
return None
elif results.count() == 1:
return results[0]
else:
raise AssertionError('Too many matching member results: %s' %
results.count())
class MemberRoster(AbstractRoster):
"""Return all the members of a list."""
name = 'member'
role = MemberRole.member
class OwnerRoster(AbstractRoster):
"""Return all the owners of a list."""
name = 'owner'
role = MemberRole.owner
class ModeratorRoster(AbstractRoster):
"""Return all the owners of a list."""
name = 'moderator'
role = MemberRole.moderator
class AdministratorRoster(AbstractRoster):
"""Return all the administrators of a list."""
name = 'administrator'
@property
def members(self):
# Administrators are defined as the union of the owners and the
# moderators.
members = config.db.store.find(
Member,
Member.mailing_list == self._mlist.fqdn_listname,
Or(Member.role == MemberRole.owner,
Member.role == MemberRole.moderator))
for member in members:
yield member
def get_member(self, address):
results = config.db.store.find(
Member,
Member.mailing_list == self._mlist.fqdn_listname,
Or(Member.role == MemberRole.moderator,
Member.role == MemberRole.owner),
Address.address == address,
Member.address_id == Address.id)
if results.count() == 0:
return None
elif results.count() == 1:
return results[0]
else:
raise AssertionError(
'Too many matching member results: %s' % results)
class RegularMemberRoster(AbstractRoster):
"""Return all the regular delivery members of a list."""
name = 'regular_members'
@property
def members(self):
# Query for all the Members which have a role of MemberRole.member and
# are subscribed to this mailing list. Then return only those members
# that have a regular delivery mode.
for member in config.db.store.find(
Member,
mailing_list=self._mlist.fqdn_listname,
role=MemberRole.member):
if member.delivery_mode == DeliveryMode.regular:
yield member
_digest_modes = (
DeliveryMode.mime_digests,
DeliveryMode.plaintext_digests,
DeliveryMode.summary_digests,
)
class DigestMemberRoster(AbstractRoster):
"""Return all the regular delivery members of a list."""
name = 'regular_members'
@property
def members(self):
# Query for all the Members which have a role of MemberRole.member and
# are subscribed to this mailing list. Then return only those members
# that have one of the digest delivery modes.
for member in config.db.store.find(
Member,
mailing_list=self._mlist.fqdn_listname,
role=MemberRole.member):
if member.delivery_mode in _digest_modes:
yield member
class Subscribers(AbstractRoster):
"""Return all subscribed members regardless of their role."""
name = 'subscribers'
@property
def members(self):
for member in config.db.store.find(
Member,
mailing_list=self._mlist.fqdn_listname):
yield member
|