def memberships(self, context, segments):
"""/addresses/<email>/memberships"""
if len(segments) != 0:
return NotFound(), []
if self._address is None:
return NotFound(), []
return AddressMemberships(self._address)
def member(self, context, segments, role, email):
"""Return a single member representation."""
if self._mlist is None:
return NotFound(), []
member = getUtility(ISubscriptionService).find_member(
email, self._mlist.list_id, role)
if member is None:
return NotFound(), []
return AMember(member.member_id)
def owners(self, context, segments):
"""/domains/<domain>/owners"""
if len(segments) == 0:
domain = getUtility(IDomainManager).get(self._domain)
if domain is None:
return NotFound()
return OwnersForDomain(domain)
else:
return NotFound(), []
def all(self, request, segments):
"""/members/<id>/all/preferences"""
if len(segments) == 0:
return NotFound(), []
if self._member is None:
return NotFound(), []
child = ReadOnlyPreferences(
self._member, 'members/{0}/all'.format(self._member.member_id.int))
return child, []
def preferences(self, request, segments):
"""/members/<id>/preferences"""
if len(segments) != 0:
return NotFound(), []
if self._member is None:
return NotFound(), []
child = Preferences(self._member.preferences,
'members/{0}'.format(self._member.member_id.int))
return child, []
def preferences(self, request, segments):
"""/addresses/<email>/preferences"""
if len(segments) != 0:
return NotFound(), []
if self._address is None:
return NotFound(), []
child = Preferences(self._address.preferences,
'addresses/{0}'.format(self._address.email))
return child, []
def all(self, context, segments):
"""/members/<id>/all/preferences"""
if len(segments) == 0:
return NotFound(), []
if self._member is None:
return NotFound(), []
member_id = self.api.from_uuid(self._member_id)
child = ReadOnlyPreferences(self._member,
'members/{}/all'.format(member_id))
return child, []
def member(self, request, segments, role, email):
"""Return a single member representation."""
if self._mlist is None:
return NotFound(), []
members = getUtility(ISubscriptionService).find_members(
email, self._mlist.list_id, role)
if len(members) == 0:
return NotFound(), []
assert len(members) == 1, 'Too many matches'
return AMember(members[0].member_id)
def preferences(self, context, segments):
"""/members/<id>/preferences"""
if len(segments) != 0:
return NotFound(), []
if self._member is None:
return NotFound(), []
member_id = self.api.from_uuid(self._member_id)
child = Preferences(self._member.preferences,
'members/{}'.format(member_id))
return child, []
def uris(self, content, segments):
if self.api.version_info < (3, 1):
return NotFound(), []
if len(segments) == 0:
return AllSiteURIs()
if len(segments) > 1:
return BadRequest(), []
template = segments[0]
if template not in AllSiteURIs.URIs:
return NotFound(), []
return ASiteURI(template), []
def uris(self, context, segments):
"""Return the template URIs of the mailing list.
These are only available after API 3.0.
"""
if self._mlist is None or self.api.version_info < (3, 1):
return NotFound(), []
if len(segments) == 0:
return AllListURIs(self._mlist)
if len(segments) > 1:
return BadRequest(), []
template = segments[0]
if template not in AllListURIs.URIs:
return NotFound(), []
return AListURI(self._mlist, template), []
def uris(self, context, segments):
"""Return the template URIs of the domain.
These are only available after API 3.0.
"""
domain = getUtility(IDomainManager).get(self._domain)
if domain is None or self.api.version_info < (3, 1):
return NotFound(), []
if len(segments) == 0:
return AllDomainURIs(domain)
if len(segments) > 1:
return BadRequest(), []
template = segments[0]
if template not in AllDomainURIs.URIs:
return NotFound(), []
return ADomainURI(domain, template), []
def system(self, context, segments):
"""/<api>/system"""
if len(segments) == 0:
# This provides backward compatibility; see /system/versions.
return Versions()
elif segments[0] == 'preferences':
if len(segments) > 1:
return BadRequest(), []
return ReadOnlyPreferences(system_preferences, 'system'), []
elif segments[0] == 'versions':
if len(segments) > 1:
return BadRequest(), []
return Versions(), []
elif segments[0] == 'configuration':
if len(segments) <= 2:
return SystemConfiguration(*segments[1:]), []
return BadRequest(), []
elif segments[0] == 'pipelines':
if len(segments) > 1:
return BadRequest(), []
return Pipelines(), []
elif segments[0] == 'chains':
if len(segments) > 1:
return BadRequest(), []
return Chains(), []
else:
return NotFound(), []
def user(self, context, segments):
"""/addresses/<email>/user"""
if self._address is None:
return NotFound(), []
# Avoid circular imports.
from mailman.rest.users import AddressUser
return AddressUser(self._address)
def unverify(self, context, segments):
"""/addresses/<email>/verify"""
if len(segments) != 0:
return BadRequest(), []
if self._address is None:
return NotFound(), []
child = _VerifyResource(self._address, 'unverify')
return child, []
def lists(self, context, segments):
"""/domains/<domain>/lists"""
if len(segments) == 0:
domain = getUtility(IDomainManager).get(self._domain)
if domain is None:
return NotFound()
return ListsForDomain(domain)
else:
return BadRequest(), []
def __init__(self, plugin_name):
self._resource = None
if plugin_name in config.plugins:
plugin = config.plugins[plugin_name]
self._resource = plugin.resource
# If the plugin doesn't exist or doesn't provide a resource, just proxy
# to NotFound.
if self._resource is None:
self._resource = NotFound()
def preferences(self, request, segments):
"""/addresses/<email>/preferences"""
if len(segments) != 0:
return BadRequest(), []
if self._user is None:
return NotFound(), []
child = Preferences(self._user.preferences,
'users/{0}'.format(self._user.user_id.int))
return child, []
def preferences(self, context, segments):
"""/users/<id>/preferences"""
if len(segments) != 0:
return BadRequest(), []
if self._user is None:
return NotFound(), []
child = Preferences(
self._user.preferences,
'users/{}'.format(self.api.from_uuid(self._user.user_id)))
return child, []
def templates(self, context, segments):
"""/<api>/templates/<fqdn_listname>/<template>/[<language>]
Use content negotiation to context language and suffix (content-type).
"""
# This resource is removed in API 3.1; use the /uris resource instead.
if self.api.version_info > (3, 0):
return NotFound(), []
if len(segments) == 3:
fqdn_listname, template, language = segments
elif len(segments) == 2:
fqdn_listname, template = segments
language = 'en'
else:
return BadRequest(), []
mlist = getUtility(IListManager).get(fqdn_listname)
if mlist is None:
return NotFound(), []
# XXX dig out content-type from context.
content_type = None
return TemplateFinder(fqdn_listname, template, language, content_type)
def plugins(self, context, segments):
"""/<api>/plugins
/<api>/plugins/<plugin_name>
/<api>/plugins/<plugin_name>/...
"""
if self.api.version_info < (3, 1):
return NotFound(), []
if len(segments) == 0:
return AllPlugins(), []
else:
plugin_name = segments.pop(0)
return APlugin(plugin_name), segments
def templates(self, request, segments):
"""/<api>/templates/<fqdn_listname>/<template>/[<language>]
Use content negotiation to request language and suffix (content-type).
"""
if len(segments) == 3:
fqdn_listname, template, language = segments
elif len(segments) == 2:
fqdn_listname, template = segments
language = 'en'
else:
return BadRequest(), []
mlist = getUtility(IListManager).get(fqdn_listname)
if mlist is None:
return NotFound(), []
# XXX dig out content-type from request
content_type = None
return TemplateFinder(fqdn_listname, template, language, content_type)
def login(self, context, segments):
"""Log the user in, sort of, by verifying a given password."""
if self._user is None:
return NotFound(), []
return Login(self._user)
def addresses(self, context, segments):
"""/users/<uid>/addresses"""
if self._user is None:
return NotFound(), []
return UserAddresses(self._user)
def header_matches(self, context, segments):
"""Return a collection of mailing list's header matches."""
if self._mlist is None:
return NotFound(), []
return HeaderMatches(self._mlist)
def bans(self, context, segments):
"""Return a collection of mailing list's banned addresses."""
if self._mlist is None:
return NotFound(), []
return BannedEmails(self._mlist)
def digest(self, context, segments):
if self._mlist is None:
return NotFound(), []
return ListDigest(self._mlist)
def archivers(self, context, segments):
"""Return a representation of mailing list archivers."""
if self._mlist is None:
return NotFound(), []
return ListArchivers(self._mlist)
def requests(self, context, segments):
"""Return a list of subscription/unsubscription requests."""
if self._mlist is None:
return NotFound(), []
return SubscriptionRequests(self._mlist)
def held(self, context, segments):
"""Return a list of held messages for the mailing list."""
if self._mlist is None:
return NotFound(), []
return HeldMessages(self._mlist)
