def __init__(self, context, request):
super(ModerationView, self).__init__(context, request)
self.mem_list = IWriteMembershipList(context)
annot = IAnnotations(self.context)
self.listen_annot = annot.setdefault(PROJECTNAME, OOBTree())
self.mod_post_pending_list = getAdapter(context, IPostPendingList, 'pending_mod_post')
self.pmod_post_pending_list = getAdapter(context, IPostPendingList, 'pending_pmod_post')
self.sub_pending_list = getAdapter(context, IMembershipPendingList, 'pending_sub_mod_email')
def add_allowed_sender(self, email):
IWriteMembershipList(self.context).add_allowed_sender(email)
def migrate(self):
if self.is_updated():
return _(u'already migrated')
# set the appropriate list type based on the previous settings
# this may need to mark the appropriate interface on the mailing
# list as well
if self.context.moderated:
self.context.list_type = PostModeratedListTypeDefinition
elif self.context.closed:
self.context.list_type = MembershipModeratedListTypeDefinition
else:
self.context.list_type = PublicListTypeDefinition
# copy over the membership stuff
annot = IAnnotations(self.context)
listen_annot = annot.get('listen', {})
old_subscribers = listen_annot.get('subscribers', [])
# create the new annotations by using current adapters
mem_list = IWriteMembershipList(self.context)
for subscriber in old_subscribers:
mem_list.subscribe(subscriber)
# unsubscribe (but leave as allowed senders) those who don't
# receive mail
nomail = listen_annot.get('norecvmail', [])
for allowed_sender in nomail:
mem_list.unsubscribe(allowed_sender)
# copy over the moderation messages
self.mod_post_pending_list = getAdapter(self.context, IPostPendingList,
'pending_pmod_post')
for i in self.context.mqueue.objectIds():
(header, body) = splitMail(self.context.mqueue[i])
post = {'header': header, 'body': body}
(user_name, user_email) = parseaddr(header.get('from', ''))
self.mod_post_pending_list.add(user_email,
user_name=user_name,
post=post)
# creates list managers from moderators and list owner
managers = []
managers.append(self.context.list_owner)
for moderator in self.context.moderators:
managers.append(moderator)
self.context.managers = tuple(managers)
convert_manager_emails_to_memberids(self.context)
# translate archived vocabulary
if self.context.archived == 'not archived':
self.context.archived = 2
elif self.context.archived == 'plain text':
self.context.archived = 1
elif self.context.archived == 'with attachments':
self.context.archived = 0
else:
return _(u'error translating archive option')
# annotate the list to say the migration completed
self.migration_annot.append('policy_migration')
return _(u'successfully migrated')
def __init__(self, context):
BaseImportExport.__init__(self, context)
self.mem_list = IWriteMembershipList(context)
def __init__(self, context):
self.context = context
annot = IAnnotations(context)
self.listen_annot = annot.setdefault(PROJECTNAME, OOBTree())
self.mail_sender = ISendMail(context)
self.mem_list = IWriteMembershipList(context)
def became_allowed_sender(event):
"""
This function should ensure that all other pending allowed sender
lists that the other policy adapters depend on are in sync.
set up the phony mailing list and policies
>>> from Products.listen.content.tests import DummyAnnotableList
>>> from Products.listen.content.tests import DummyMembershipTool
>>> from Products.listen.extras.tests import TestMailingList
>>> from Products.listen.content.tests import DummyMember
>>> from Products.listen.config import POST_DEFERRED, MEMBERSHIP_DEFERRED
>>> ml = TestMailingList()
>>> from zope.interface import alsoProvides
>>> from Products.listen.interfaces import IPublicList
>>> alsoProvides(ml, IPublicList)
>>> mails_to_list = []
>>> def listMail(post):
... mails_to_list.append(post)
>>> ml.listMail = listMail
>>> from Products.listen.interfaces import IMailingList
>>> dtool = DummyMembershipTool('foo')
>>> dtool.result = None
>>> ml.portal_membership = dtool
>>> from Products.listen.content import WriteMembershipList
>>> mlist = WriteMembershipList(ml)
>>> from zope.component import getAdapter
>>> from zope.component import provideAdapter
>>> from Products.listen.interfaces import IEmailPostPolicy
>>> from Products.listen.interfaces import IUserEmailMembershipPolicy
>>> from Products.listen.content import PublicEmailPostPolicy
>>> from Products.listen.content import UserMembershipPolicy
>>> postpolicy = getAdapter(ml, IEmailPostPolicy)
>>> mempolicy = getAdapter(ml, IUserEmailMembershipPolicy)
send a subscribe email to get on the pending list
>>> request = dict(email='*****@*****.**',
... subject='subscribe')
>>> mempolicy.enforce(request) == MEMBERSHIP_DEFERRED
True
now submit a post to get on that pending list
>>> request = dict(email='*****@*****.**',
... post=dict(header={}, body='there is only zul!'))
>>> postpolicy.enforce(request) == POST_DEFERRED
True
now add the email as an allowed sender
>>> mlist.add_allowed_sender('*****@*****.**')
make sure he's not on the allowed sender pending list
>>> from zope.annotation.interfaces import IAnnotations
>>> annot = IAnnotations(ml)
>>> listen_annot = annot['listen']
>>> a_s_list = listen_annot['a_s_pending_sub_email']
>>> '*****@*****.**' in a_s_list
False
verify that the post is no longer pending and has been sent out
>>> post_list = listen_annot['pending_mod_post']
>>> '*****@*****.**' in post_list
False
>>> 'there is only zul!' in mails_to_list[0]['Mail']
True
try with a mem-moderated list policy
>>> from zope.interface import directlyProvides
>>> from Products.listen.interfaces import IMembershipModeratedList
>>> directlyProvides(ml, IMembershipModeratedList)
>>> postpolicy = getAdapter(ml, IEmailPostPolicy)
>>> request = dict(email='*****@*****.**',
... post=dict(header={}, body='there is only zui!'))
>>> postpolicy.enforce(request) == POST_DEFERRED
True
>>> mlist.add_allowed_sender('*****@*****.**')
>>> '*****@*****.**' in post_list
False
>>> 'there is only zui!' in mails_to_list[1]['Mail']
True
make someone who is pending subscription moderation an allowed sender
and make sure they get automatically subscribed
>>> from Products.listen.interfaces import IMembershipPendingList
>>> sub_mod_pending_list = getAdapter(ml, IMembershipPendingList, 'pending_sub_mod_email')
>>> sub_mod_pending_list.add('*****@*****.**')
>>> mlist.add_allowed_sender('*****@*****.**')
>>> mlist.is_subscribed('*****@*****.**')
True
now try subscribing a member who is pending subscription moderation
>>> sub_mod_pending_list.add('*****@*****.**')
>>> mlist.subscribe('*****@*****.**')
>>> mlist.is_subscribed('*****@*****.**')
True
"""
email = event.email
context = event.context
# clean up pending subscription
pend_list = getAdapter(context, IPostPendingList, 'a_s_pending_sub_email')
pend_list.remove(email)
# if member is waiting for moderation to become a subscriber
# then subscribe member
sub_pending_list = getAdapter(context, IMembershipPendingList, 'pending_sub_mod_email')
if sub_pending_list.is_pending(email):
mlist = IWriteMembershipList(context)
mail_sender = ISendMail(context)
sub_pending_list.remove(email)
mlist.subscribe(email)
mail_sender.user_welcome(email, email)
# clean up pending posts
post_mod_list = getAdapter(context, IPostPendingList, 'pending_mod_post')
# XXX currently expecting one post,
# this is not the case for Post Moderated Lists
# send the post for the user to the list
posts = post_mod_list.get_posts(email)
# uniquify posts
post_dict = {}
for p in posts:
post_dict[p['body']] = p['header']
posts = [dict(header=v, body=k) for k,v in post_dict.iteritems()]
send_pending_posts(context, posts)
post_mod_list.remove(email)
def __init__(self, context, request):
super(ManageMembersView, self).__init__(context, request)
self.policy = getAdapter(context, IManagerTTWMembershipPolicy)
self.mem_list = IWriteMembershipList(context)
def __call__(self):
sub_action = self.request.get('subscribe_member', None)
unsub_action = self.request.get('unsubscribe_member', None)
email_action = self.request.get('subscribe_email', None)
self.request.set('enable_border', True)
self.errors = errors = {}
logged_in_mem = self._get_logged_in_user()
self.user_logged_in = False
if logged_in_mem:
self.user_email = lookup_email(logged_in_mem.getId(), self.context)
self.user_logged_in = True
else:
#XXX what should this be?
self.user_email = ''
self.mem_list = IWriteMembershipList(self.context)
# the appropriate sub_policy needs to be instantiated
# depending on list type
self.sub_policy = getAdapter(self.context, IUserTTWMembershipPolicy)
if sub_action:
self.subscribe()
elif unsub_action:
self.unsubscribe()
elif email_action:
address = self.request.get('email_address', None)
if not address:
errors['email_address'] = _('An email address is required')
elif EMAIL_RE.match(address) is None:
errors['email_address'] = _('This email address is invalid')
elif self.mem_list.is_subscribed(address):
errors['email_address'] = \
_('This email address is already subscribed')
else:
# everything is OK, send a request mail the
# appropriate sub_policy needs to be instantiated
# depending on list type
sub_policy_for_email = getAdapter(self.context, IUserEmailMembershipPolicy)
ret = sub_policy_for_email.enforce({'email':address,
'subject':'subscribe'})
if ret == MEMBERSHIP_ALLOWED:
# make user a subscriber
self.mem_list.subscribe(address)
self.request.set('portal_status_message', _(u'list_email_subscribed_status_msg',
u'Email subscribed'))
elif ret == MEMBERSHIP_DEFERRED:
self.request.set('portal_status_message',
_(u'list_subscription_request_sent_status_msg',
u'Subscription request sent'))
else:
self.request.set('portal_status_message', _(u'list_bad_email_address_status_msg',
u'Bad email address'))
# Blank the email field to avoid the postback
self.request.set('email_address', '')
self.request.set('subscribe_email', '')
return self.index()
