def add_or_remove_membership(mship, remove=False):
mem_id = mship.getId()
team = mship.aq_inner.aq_parent
proj_id = team.getId()
portal = getToolByName(mship, 'portal_url').getPortalObject()
listencontainer = portal.projects[proj_id].lists
mlists = []
for mlist in listencontainer.objectValues(spec='OpenMailingList'):
if ISyncWithProjectMembership.providedBy(mlist):
mlists.append(mlist)
if not mlists:
# no autosync mailing lists; silently fail
return
for ml in mlists:
memlist = IWriteMembershipList(ml)
if remove:
memlist.unsubscribe(mem_id)
else:
memlist.subscribe(mem_id)
def migrate(self):
if self.is_updated():
return '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 'error translating archive option'
# annotate the list to say the migration completed
self.migration_annot.append('policy_migration')
return 'successfully migrated'
class ManageMembersView(BrowserView):
"""A basic view of displaying subscribed members and allowed senders """
def __init__(self, context, request):
super(ManageMembersView, self).__init__(context, request)
self.policy = getAdapter(context, IManagerTTWMembershipPolicy)
self.mem_list = IWriteMembershipList(context)
def __call__(self):
if not self.request.get('save', None): return self.index()
d = self.request.form
self.errors = ''
to_remove = []
subscribed_list = set()
wassubscribed_list = set()
for name, value in d.items():
if name.lower() == 'save' and value.lower() == 'save changes': continue
valuetype, name = name.split('_', 1)
if valuetype == 'remove':
to_remove.append(name.decode('utf-8'))
elif valuetype == 'subscribed':
subscribed_list.add(name.decode('utf-8'))
elif valuetype == 'wassubscribed':
wassubscribed_list.add(name.decode('utf-8'))
to_subscribe = subscribed_list - wassubscribed_list
to_unsubscribe = wassubscribed_list - subscribed_list
self._remove(to_remove)
self._subscribe(to_subscribe)
self._unsubscribe(to_unsubscribe)
psm = ""
to_add = d.get('add_email', None).strip()
if to_add:
subscribed = d.get('add_subscribed', None)
if self._add(to_add, subscribed):
psm += 'Added: %s. ' % to_add
else:
psm += 'Bad user or email address: %s. ' % to_add
if to_remove:
psm += _(u'Removed: %s. ') % ', '.join(to_remove)
if to_subscribe:
psm += _(u'Subscribed: %s. ') % ', '.join(to_subscribe)
if to_unsubscribe:
psm += 'Unsubscribed: %s. ' % ', '.join(to_unsubscribe)
if psm:
context = aq_inner(self.context)
plone_utils = getToolByName(context, 'plone_utils')
plone_utils.addPortalMessage(psm)
# since this means that we've been posted to
# we should redirect
self.request.response.redirect(self.nextURL())
def nextURL(self):
return '%s/%s' % (self.context.absolute_url(), self.__name__)
def can_subscribe_others(self):
return False
def _add(self, user, subscribed, subscribe_directly=False):
request = {'action': 'add_allowed_sender', 'email': user}
policy_result = self.policy.enforce(request)
if policy_result == MEMBERSHIP_ALLOWED:
self.mem_list.add_allowed_sender(user)
elif policy_result == MEMBERSHIP_DENIED:
return False
if subscribed:
request = {'action': 'subscribe', 'email': user}
if subscribe_directly and self.can_subscribe_others():
self.mem_list.subscribe(user)
else:
result = self.policy.enforce(request)
if result == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(user)
return True
def _remove(self, remove_list):
for user in remove_list:
if self.mem_list.is_subscribed(user):
request = {'action': 'unsubscribe', 'email':user}
else:
request = {'action': 'remove_allowed_sender', 'email':user}
if self.policy.enforce(request) == MEMBERSHIP_ALLOWED:
self.mem_list.remove_allowed_sender(user)
def _subscribe_user_directly(self, user):
return False
def _subscribe(self, add_list):
can_subscribe_others = self.can_subscribe_others()
for user in add_list:
if can_subscribe_others and self._subscribe_user_directly(user):
self.mem_list.subscribe(user)
continue
request = {'action': 'subscribe', 'email': user}
policy_result = self.policy.enforce(request)
if policy_result == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(user)
def _unsubscribe(self, remove_list):
for user in remove_list:
request = {'action': 'unsubscribe', 'email': user}
if self.policy.enforce(request) == MEMBERSHIP_ALLOWED:
self.mem_list.unsubscribe(user)
def Title(self):
return _(u'Manage Allowed Senders')
def Description(self):
return _(u'Manage Allowed Senders')
def allowed_senders_data(self):
return self.mem_list.allowed_senders_data
def is_subscribed(self, user):
return self.mem_list.is_subscribed(user)
def pending_status(self, user):
annot = IAnnotations(self.context)
listen_annot = annot.setdefault(PROJECTNAME, OOBTree())
subscribe_pending_list = getAdapter(self.context, IMembershipPendingList, 'pending_sub_email')
unsubscribe_pending_list = getAdapter(self.context, IMembershipPendingList, 'pending_unsub_email')
sub_mod_pending_list = getAdapter(self.context, IMembershipPendingList, 'pending_sub_mod_email')
email_address = is_email(user) and user or lookup_email(user, self.context)
inlist = lambda lst: lst.is_pending(email_address)
status = lambda msg, lst: msg + lst.get_pending_time(email_address)
status_msg = ''
if inlist(subscribe_pending_list):
status_msg += status('subscription pending user confirmation: ', subscribe_pending_list)
if inlist(unsubscribe_pending_list):
status_msg += status('unsubscription pending user confirmation: ', unsubscribe_pending_list)
if inlist(sub_mod_pending_list):
status_msg += status('subscription pending manager moderation: ', sub_mod_pending_list)
return status_msg
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')
class MailingListView(BrowserView):
"""A basic view of a mailing list"""
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', 'Email subscribed')
elif ret == MEMBERSHIP_DEFERRED:
self.request.set('portal_status_message',
'Subscription request sent')
else:
self.request.set('portal_status_message', 'Bad email address')
# Blank the email field to avoid the postback
self.request.set('email_address', '')
self.request.set('subscribe_email', '')
return self.index()
def Title(self):
return encode(self.context.title, self.context)
def Description(self):
return encode(self.context.description, self.context)
def address(self):
if not self.context.mailto:
return u''
return obfct_de(encode(self.context.mailto, self.context))
def archived(self):
archived = self.context.archived
vocab = archiveOptionsVocabulary(self.context)
return vocab.getTerm(archived).token + '. '
def is_archived(self):
return self.context._is_archived()
def list_managers(self):
managers = []
creator = self.context.Creator()
for manager in self.context.managers:
if manager == creator:
managers.append('%s (creator)' % manager)
else:
managers.append(manager)
return managers
def list_title(self):
return self.context.Title()
def list_type(self):
list_type = self.context.list_type
if list_type is None:
return _(u'List Type not set')
return '%s. %s' % (list_type.title, list_type.description)
def subscribe_keyword(self):
# Mailboxer stores the subject line keyword used for subscribing as
# a property
return self.context.getValueFor('subscribe')
def unsubscribe_keyword(self):
# Mailboxer stores the subject line keyword used for unsubscribing as
# a property
return self.context.getValueFor('unsubscribe')
def subscribe(self):
req = {'action':'subscribe', 'email':self.user_email}
if self.user_logged_in:
req['use_logged_in_user'] = True
ret = self.sub_policy.enforce(req)
if ret == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(self.user_email)
self.request.set('portal_status_message',
'You have been subscribed')
pass
elif ret == MEMBERSHIP_DEFERRED:
self.request.set('portal_status_message',
'Your subscription request is pending moderation '
'by the list manager.')
def unsubscribe(self):
self.mem_list.unsubscribe(self.user_email)
self.request.set('portal_status_message', 'You have been unsubscribed')
def _get_logged_in_user(self):
mtool = getToolByName(self.context, 'portal_membership')
return mtool.getAuthenticatedMember()
def isSubscribed(self):
if self.user_email:
return self.mem_list.is_subscribed(self.user_email)
else:
return False
def isPending(self):
annot = IAnnotations(self.context)
sub_mod_pending_list = getAdapter(self.context,
IMembershipPendingList,
'pending_sub_mod_email')
return sub_mod_pending_list.is_pending(self.user_email)
def canSubscribe(self):
return _checkPermission(SubscribeSelf, self.context)
def manager_email(self):
if not self.context.manager_email:
return u''
return obfct_de(self.context.manager_email)
class ManageMembersView(BrowserView):
"""A basic view of displaying subscribed members and allowed senders """
def __init__(self, context, request):
super(ManageMembersView, self).__init__(context, request)
self.policy = getAdapter(context, IManagerTTWMembershipPolicy)
self.mem_list = IWriteMembershipList(context)
def __call__(self):
if not self.request.get('save', None): return self.index()
d = self.request.form
self.errors = ''
to_remove = []
subscribed_list = set()
wassubscribed_list = set()
for name, value in d.items():
if name.lower() == 'save' and value.lower() == 'save changes':
continue
valuetype, name = name.split('_', 1)
if valuetype == 'remove':
to_remove.append(name.decode('utf-8'))
elif valuetype == 'subscribed':
subscribed_list.add(name.decode('utf-8'))
elif valuetype == 'wassubscribed':
wassubscribed_list.add(name.decode('utf-8'))
to_subscribe = subscribed_list - wassubscribed_list
to_unsubscribe = wassubscribed_list - subscribed_list
self._remove(to_remove)
self._subscribe(to_subscribe)
self._unsubscribe(to_unsubscribe)
psm = ""
to_add = d.get('add_email', None).strip()
if to_add:
subscribed = d.get('add_subscribed', None)
if self._add(to_add, subscribed):
psm += _(u'add_subscribed_portal_msg',
u'Added: ${to_add}. ',
mapping={'to_add': to_add})
else:
psm += _(u'bad_user_email_portal_msg',
u'Bad user or email address: ${to_add}. ',
mapping={'to_add': to_add})
if to_remove:
psm += _(u'removed_portal_msg',
u'Removed: ${to_remove}. ',
mapping={'to_remove': to_remove})
if to_subscribe:
psm += _(u'subscribed_portal_msg',
u'Subscribed: ${to_subscribe}. ',
mapping={'to_subscribe': to_subscribe})
if to_unsubscribe:
psm += _(u'unsubscribed_portal_msg',
u'Unsubscribed: ${to_unsubscribe}. ',
mapping={'to_unsubscribe': to_unsubscribe})
if psm:
context = aq_inner(self.context)
plone_utils = getToolByName(context, 'plone_utils')
plone_utils.addPortalMessage(psm)
# since this means that we've been posted to
# we should redirect
self.request.response.redirect(self.nextURL())
def nextURL(self):
return '%s/%s' % (self.context.absolute_url(), self.__name__)
def can_subscribe_others(self):
return False
def _add(self, user, subscribed, subscribe_directly=False):
request = {'action': 'add_allowed_sender', 'email': user}
policy_result = self.policy.enforce(request)
if policy_result == MEMBERSHIP_ALLOWED:
self.mem_list.add_allowed_sender(user)
elif policy_result == MEMBERSHIP_DENIED:
return False
if subscribed:
request = {'action': 'subscribe', 'email': user}
if subscribe_directly and self.can_subscribe_others():
self.mem_list.subscribe(user)
else:
result = self.policy.enforce(request)
if result == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(user)
return True
def _remove(self, remove_list):
for user in remove_list:
if self.mem_list.is_subscribed(user):
request = {'action': 'unsubscribe', 'email': user}
else:
request = {'action': 'remove_allowed_sender', 'email': user}
if self.policy.enforce(request) == MEMBERSHIP_ALLOWED:
self.mem_list.remove_allowed_sender(user)
def _subscribe_user_directly(self, user):
return False
def _subscribe(self, add_list):
can_subscribe_others = self.can_subscribe_others()
for user in add_list:
if can_subscribe_others and self._subscribe_user_directly(user):
self.mem_list.subscribe(user)
continue
request = {'action': 'subscribe', 'email': user}
policy_result = self.policy.enforce(request)
if policy_result == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(user)
def _unsubscribe(self, remove_list):
for user in remove_list:
request = {'action': 'unsubscribe', 'email': user}
if self.policy.enforce(request) == MEMBERSHIP_ALLOWED:
self.mem_list.unsubscribe(user)
def Title(self):
return _(u'Manage Allowed Senders')
def Description(self):
return _(u'Manage Allowed Senders')
def allowed_senders_data(self):
return self.mem_list.allowed_senders_data
def is_subscribed(self, user):
return self.mem_list.is_subscribed(user)
def pending_status(self, user):
annot = IAnnotations(self.context)
listen_annot = annot.setdefault(PROJECTNAME, OOBTree())
subscribe_pending_list = getAdapter(self.context,
IMembershipPendingList,
'pending_sub_email')
unsubscribe_pending_list = getAdapter(self.context,
IMembershipPendingList,
'pending_unsub_email')
sub_mod_pending_list = getAdapter(self.context, IMembershipPendingList,
'pending_sub_mod_email')
email_address = is_email(user) and user or lookup_email(
user, self.context)
inlist = lambda lst: lst.is_pending(email_address)
status = lambda msg, lst: msg + lst.get_pending_time(email_address)
status_msg = ''
if inlist(subscribe_pending_list):
status_msg += status(
_(u'subscription pending user confirmation: '),
subscribe_pending_list)
if inlist(unsubscribe_pending_list):
status_msg += status(
_(u'unsubscription pending user confirmation: '),
unsubscribe_pending_list)
if inlist(sub_mod_pending_list):
status_msg += status(
_(u'subscription pending manager moderation: '),
sub_mod_pending_list)
return status_msg
class MailingListView(BrowserView):
"""A basic view of a mailing list"""
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()
def Title(self):
return encode(self.context.title, self.context)
def Description(self):
return encode(self.context.description, self.context)
def address(self):
if not self.context.mailto:
return u''
return obfct_de(encode(self.context.mailto, self.context))
def archived(self):
archived = self.context.archived
vocab = archiveOptionsVocabulary(self.context)
return vocab.getTerm(archived).token + '. '
def is_archived(self):
return self.context._is_archived()
def list_managers(self):
managers = []
creator = self.context.Creator()
for manager in self.context.managers:
if manager == creator:
managers.append('%s (creator)' % manager)
else:
managers.append(manager)
return managers
def list_title(self):
return self.context.Title()
def list_type(self):
list_type = self.context.list_type
if list_type is None:
return _(u'list_type_not_set', u'List Type not set')
return '%s. %s' % (list_type.title, list_type.description)
def subscribe_keyword(self):
# Mailboxer stores the subject line keyword used for subscribing as
# a property
return self.context.getValueFor('subscribe')
def unsubscribe_keyword(self):
# Mailboxer stores the subject line keyword used for unsubscribing as
# a property
return self.context.getValueFor('unsubscribe')
def subscribe(self):
req = {'action':'subscribe', 'email':self.user_email}
if self.user_logged_in:
req['use_logged_in_user'] = True
ret = self.sub_policy.enforce(req)
if ret == MEMBERSHIP_ALLOWED:
self.mem_list.subscribe(self.user_email)
self.request.set('portal_status_message',
_(u'list_have_been_subscribed_status_msg',
u'You have been subscribed'))
pass
elif ret == MEMBERSHIP_DEFERRED:
self.request.set('portal_status_message',
_(u'list_subscription_pending_moderation_status_msg',
u"Your subscription request is pending moderation by the list manager."))
def unsubscribe(self):
self.mem_list.unsubscribe(self.user_email)
self.request.set('portal_status_message', _(u'list_have_been_unsubscribed_status_msg',
u"You have been unsubscribed"))
def _get_logged_in_user(self):
mtool = getToolByName(self.context, 'portal_membership')
return mtool.getAuthenticatedMember()
def isSubscribed(self):
if self.user_email:
return self.mem_list.is_subscribed(self.user_email)
else:
return False
def isPending(self):
annot = IAnnotations(self.context)
sub_mod_pending_list = getAdapter(self.context,
IMembershipPendingList,
'pending_sub_mod_email')
return sub_mod_pending_list.is_pending(self.user_email)
def canSubscribe(self):
return _checkPermission(SubscribeSelf, self.context)
def manager_email(self):
if not self.context.manager_email:
return u''
return obfct_de(self.context.manager_email)
