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
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', '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 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)
