def all(self, request, segments):
     """/members/<id>/all/preferences"""
     if len(segments) == 0:
         return http.not_found()
     if self._member is None:
         return http.not_found()
     child = ReadOnlyPreferences(
         self._member,
         'members/{0}/all'.format(self._member.member_id.int))
     return child, []

 def member(self, request, segments, role, email):
     """Return a single member representation."""
     if self._mlist is None:
         return http.not_found()
     members = getUtility(ISubscriptionService).find_members(
         email, self._mlist.list_id, role)
     if len(members) == 0:
         return http.not_found()
     assert len(members) == 1, 'Too many matches'
     return AMember(members[0].member_id)

 def test_not_found(self):
     r = http.not_found()
     assert r.status.startswith('404')
     assert r.headers['Content-Type'] == 'text/plain'
     assert '404 Not Found' in r.body
     r = http.not_found([('Content-Type', 'text/html')], '<p>404 Not Found</p>')
     assert r.status.startswith('404')
     assert r.headers['Content-Type'] == 'text/html'
     assert r.body == '<p>404 Not Found</p>'
     exc = http.NotFoundError()
     r = exc.make_response()
     assert r.status.startswith('404')

    def child(self, request, segments):
        if isinstance(self.metadata, dict):
            meta = self.metadata.get(segments[0])
        elif isinstance(self.metadata, list):
            try:
                index = int(segments[0])
            except ValueError:
                meta = None
            else:
                if index < 0:
                    meta = None
                else:
                    try:
                        meta = self.metadata[index]
                    except IndexError:
                        meta = None
        else:
            meta = None

        if meta is None:
            return http.not_found()

        if isinstance(meta, Named):
            meta = meta.value

        return MetaData(metadata=meta), segments[1:]

    def patch_membership(self, request):
        """Patch the membership.

        This is how subscription changes are done.
        """
        if self._member is None:
            return http.not_found()
        try:
            values = Validator(
                address=unicode,
                delivery_mode=enum_validator(DeliveryMode),
                _optional=('address', 'delivery_mode'))(request)
        except ValueError as error:
            return http.bad_request([], str(error))
        if 'address' in values:
            email = values['address']
            address = getUtility(IUserManager).get_address(email)
            if address is None:
                return http.bad_request([], b'Address not registered')
            try:
                self._member.address = address
            except (MembershipError, UnverifiedAddressError) as error:
                return http.bad_request([], str(error))
        if 'delivery_mode' in values:
            self._member.preferences.delivery_mode = values['delivery_mode']
        return no_content()

 def moderate(self, request):
     try:
         validator = Validator(action=enum_validator(Action))
         arguments = validator(request)
     except ValueError as error:
         return http.bad_request([], str(error))
     requests = IListRequests(self._mlist)
     try:
         request_id = int(self._request_id)
     except ValueError:
         return http.bad_request()
     results = requests.get_request(request_id)
     if results is None:
         return http.not_found()
     key, data = results
     try:
         request_type = RequestType(data['_request_type'])
     except ValueError:
         return http.bad_request()
     if request_type is RequestType.subscription:
         handle_subscription(self._mlist, request_id, **arguments)
     elif request_type is RequestType.unsubscription:
         handle_unsubscription(self._mlist, request_id, **arguments)
     else:
         return http.bad_request()
     return no_content()

 def memberships(self, request, segments):
     """/addresses/<email>/memberships"""
     if len(segments) != 0:
         return http.bad_request()
     if self._address is None:
         return http.not_found()
     return AddressMemberships(self._address)

 def delete(self, request):
     """Delete the member (i.e. unsubscribe)."""
     # Leaving a list is a bit different than deleting a moderator or
     # owner.  Handle the former case first.  For now too, we will not send
     # an admin or user notification.
     if self._member is None:
         return http.not_found()
     mlist = getUtility(IListManager).get_by_list_id(self._member.list_id)
     if self._member.role is MemberRole.member:
         try:
             delete_member(mlist, self._member.address.email, False, False)
         except NotAMemberError:
             return http.not_found()
     else:
         self._member.unsubscribe()
     return no_content()

 def find_template(self, request):
     # XXX We currently only support .txt and .html files.
     extension = EXTENSIONS.get(self.content_type)
     if extension is None:
         return http.not_found()
     template = self.template + extension
     fp = None
     try:
         try:
             path, fp = find(template, self.mlist, self.language)
         except TemplateNotFoundError:
             return http.not_found()
         else:
             return fp.read()
     finally:
         if fp is not None:
             fp.close()

 def unverify(self, request, segments):
     """/addresses/<email>/verify"""
     if len(segments) != 0:
         return http.bad_request()
     if self._address is None:
         return http.not_found()
     child = _VerifyResource(self._address, 'unverify')
     return child, []

 def delete(self, request):
     """Delete the domain."""
     try:
         getUtility(IDomainManager).remove(self._domain)
     except KeyError:
         # The domain does not exist.
         return http.not_found()
     return no_content()

 def serve(self, request):
     if isinstance(self.metadata, (dict, list)):
         return http.not_found()
     else:
         return http.ok(
             [('Content-Type', 'text/plain')],
             [self.metadata],
             )

 def lists(self, request, segments):
     """/domains/<domain>/lists"""
     if len(segments) == 0:
         domain = getUtility(IDomainManager).get(self._domain)
         if domain is None:
             return http.not_found()
         return ListsForDomain(domain)
     else:
         return http.bad_request()

    def status(self, request):
        session = models.Session.get_by_key_name(self.name)
        if session is None:
            return http.not_found([], '')

        return http.ok(
            [('Content-Type', 'application/json')],
            json.dumps({'created_at': str(session.created_at)})
        )

 def details(self, request):
     try:
         request_id = int(self._request_id)
     except ValueError:
         return http.bad_request()
     resource = self._make_resource(request_id)
     if resource is None:
         return http.not_found()
     return http.ok([], etag(resource))

 def preferences(self, request, segments):
     """/addresses/<email>/preferences"""
     if len(segments) != 0:
         return http.bad_request()
     if self._user is None:
         return http.not_found()
     child = Preferences(
         self._user.preferences,
         'users/{0}'.format(self._user.user_id.int))
     return child, []

 def preferences(self, request, segments):
     """/members/<id>/preferences"""
     if len(segments) != 0:
         return http.bad_request()
     if self._member is None:
         return http.not_found()
     child = Preferences(
         self._member.preferences,
         'members/{0}'.format(self._member.member_id.int))
     return child, []

 def delete_user(self, request):
     """Delete the named user, all her memberships, and addresses."""
     if self._user is None:
         return http.not_found()
     for member in self._user.memberships.members:
         member.unsubscribe()
     user_manager = getUtility(IUserManager)
     for address in self._user.addresses:
         user_manager.delete_address(address)
     user_manager.delete_user(self._user)
     return no_content()

 def child(self, request, segments):
     """
     Find the appropriate image to return including cacheing and resizing
     """
     # Build the full filename from the segments.
     filestore, key = util.decode_file_resource_path('/'.join(segments))
     # get the requested filepath from the segments
     etag = str(request.if_none_match)
     f = self.get_file(request, filestore, key, etag)
     if f:
         return f
     return http.not_found()

    def scrape(self, request):
        session = models.Session.get_by_key_name(self.name)
        if session is None:
            return http.not_found([], '')

        data = json.loads(request.body)

        content, matched = session.scrape(data['url'], data['match'])

        return http.ok(
            [('Content-Type', 'application/json')],
            json.dumps({'content': content, 'matched': matched})
        )