def setUp(self):
super(ListMembersOptionsTest, self).setUp()
self.domain = get_client().create_domain('example.com')
self.foo_list = self.domain.create_list('foo')
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpass')
self.superuser = User.objects.create_superuser('testsu',
'*****@*****.**',
'testpass')
self.owner = User.objects.create_user('testowner', '*****@*****.**',
'testpass')
self.moderator = User.objects.create_user('testmoderator',
'*****@*****.**',
'testpass')
self.foo_list.add_owner('*****@*****.**')
self.foo_list.add_moderator('*****@*****.**')
self.mm_user = get_client().create_user('*****@*****.**', '')
self.mm_user.addresses[0].verify()
self.foo_list.subscribe('*****@*****.**',
pre_verified=True,
pre_confirmed=True,
pre_approved=True)
self.url = reverse('list_member_options',
args=(
self.foo_list.list_id,
'*****@*****.**',
))
self.url = quote(self.url)
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('testlist')
except HTTPError:
self.test_list = get_client().get_list('testlist.example.com')
settings = self.test_list.settings
settings['subscription_policy'] = 'moderate'
settings.save()
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'pwd')
self.owner = User.objects.create_user(
'testowner', '*****@*****.**', 'pwd')
self.moderator = User.objects.create_user(
'testmoderator', '*****@*****.**', 'pwd')
self.su = User.objects.create_superuser(
'testsu', '*****@*****.**', 'supwd')
if self.owner.email not in self.test_list.owners:
self.test_list.add_owner('*****@*****.**')
if self.moderator.email not in self.test_list.moderators:
self.test_list.add_moderator('*****@*****.**')
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('test_list')
except HTTPError:
self.test_list = get_client().get_list('test_list.example.com')
settings = self.test_list.settings
settings['subscription_policy'] = 'moderate'
settings.save()
self.user = User.objects.create_user('testuser',
'*****@*****.**', 'pwd')
self.owner = User.objects.create_user('testowner',
'*****@*****.**', 'pwd')
self.moderator = User.objects.create_user('testmoderator',
'*****@*****.**',
'pwd')
self.su = User.objects.create_superuser('testsu', '*****@*****.**',
'supwd')
self.test_list.add_owner('*****@*****.**')
self.test_list.add_moderator('*****@*****.**')
self.client.login(username='******', password='******')
if len(self.test_list.requests) == 0:
self.client.post(
reverse('list_subscribe', args=('test_list.example.com', )),
{'email': '*****@*****.**'})
self.client.logout()
self.task = create_subscription_tasks([self.test_list])
self.events = EventTracker.objects.all()
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('test_list')
except HTTPError:
self.test_list = get_client().get_list('test_list.example.com')
settings = self.test_list.settings
settings['subscription_policy'] = 'moderate'
settings.save()
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'pwd')
self.owner = User.objects.create_user(
'testowner', '*****@*****.**', 'pwd')
self.moderator = User.objects.create_user(
'testmoderator', '*****@*****.**', 'pwd')
self.su = User.objects.create_superuser(
'testsu', '*****@*****.**', 'supwd')
self.test_list.add_owner('*****@*****.**')
self.test_list.add_moderator('*****@*****.**')
self.client.login(username='******', password='******')
if len(self.test_list.requests) == 0:
self.client.post(reverse('list_subscribe', args=('test_list.example.com', )),
{'email': '*****@*****.**'})
self.client.logout()
self.task = create_subscription_tasks([self.test_list])
self.events = EventTracker.objects.all()
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
self.foo_list = self.domain.create_list('foo')
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
self.foo_list = self.domain.create_list('foo')
def setUp(self):
self.client = Client()
self.user = User.objects.create_user('user', '*****@*****.**', 'pwd')
self.superuser = User.objects.create_superuser('su', '*****@*****.**',
'pwd')
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
def setUp(self):
# Create domain `example.com` in Mailman
try:
example_com = get_client().create_domain('example.com')
except HTTPError:
example_com = get_client().get_domain('example.com')
self.m_list = example_com.create_list('test_list')
self.test_user = User.objects.create_user(
'test_user', '*****@*****.**', 'pwd')
self.test_superuser = User.objects.create_superuser(
'test_superuser', '*****@*****.**', 'pwd')
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
self.foo_list = self.domain.create_list('foo')
self.su = User.objects.create_superuser('su', '*****@*****.**', 'pwd')
# login and post new moderator data to url
self.client.login(username='******', password='******')
self.client.post(reverse('list_members', args=('*****@*****.**', )),
{'moderator_email': '*****@*****.**'})
moderators = self.foo_list.moderators
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
self.foo_list = self.domain.create_list('foo')
self.su = User.objects.create_superuser(
'su', '*****@*****.**', 'pwd')
# login and post new moderator data to url
self.client.login(username='******', password='******')
self.client.post(
reverse('list_members', args=('*****@*****.**', )),
{'moderator_email': '*****@*****.**'})
moderators = self.foo_list.moderators
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('testlist')
except HTTPError:
self.test_list = get_client().get_list('testlist.example.com')
settings = self.test_list.settings
settings['subscription_policy'] = 'moderate'
settings.save()
self.su = User.objects.create_superuser(
'testsu', '*****@*****.**', 'supwd')
def all(self, only_public=False):
try:
objects = getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError, e:
raise MailmanApiError(e)
def post(self, request, list_id, email):
try:
client = utils.get_client()
mm_member = client.get_member(list_id, email)
mm_list = client.get_list(list_id)
preferences_form = UserPreferences(request.POST)
if preferences_form.is_valid():
preferences = mm_member.preferences
for key in preferences_form.fields.keys():
preferences[key] = preferences_form.cleaned_data[key]
preferences.save()
messages.success(
request, 'The member\'s preferences have been updated.')
else:
messages.error(request, 'Something went wrong.')
# this is a bit silly, since we already have the preferences,
# but I want to be sure we don't show stale data.
settingsform = UserPreferences(initial=mm_member.preferences)
except MailmanApiError:
return utils.render_api_error(request)
except HTTPError as e:
messages.error(request, e.msg)
return render_to_response(
'postorius/lists/memberoptions.html',
{'mm_member': mm_member,
'list': mm_list,
'settingsform': settingsform,
},
context_instance=RequestContext(request))
def all(self):
try:
return getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError, e:
raise MailmanApiError(e)
def all(self):
try:
return getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError as e:
raise MailmanApiError(e)
def all(self, only_public=False):
try:
objects = getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError, e:
raise MailmanApiError(e)
def _add_address(request, user_email, address):
# Add an address to a user record in mailman.
try:
mailman_user = utils.get_client().get_user(user_email)
mailman_user.add_address(address)
except (MailmanApiError, MailmanConnectionError) as e:
messages.error(request, 'The address could not be added.')
def setUp(self):
self.mm_client = get_client()
if self.use_vcr:
cm = self._mm_vcr.use_cassette('.'.join([
self.__class__.__name__, self._testMethodName, 'yaml']))
self.cassette = cm.__enter__()
self.addCleanup(cm.__exit__, None, None, None)
def handle_subscription_request(request, list_id, request_id, action):
"""
Handle a subscription request. Possible actions:
- accept
- defer
- reject
- discard
"""
confirmation_messages = {
'accept': _('The request has been accepted.'),
'reject': _('The request has been rejected.'),
'discard': _('The request has been discarded.'),
'defer': _('The request has been defered.'),
}
try:
m_list = utils.get_client().get_list(list_id)
# Moderate request and add feedback message to session.
m_list.moderate_request(request_id, action)
messages.success(request, confirmation_messages[action])
except MailmanApiError:
return utils.render_api_error(request)
except HTTPError as e:
messages.error(request, '{0}: {1}'.format(
_('The request could not be moderated'), e.reason))
return redirect('list_subscription_requests', m_list.list_id)
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('open_list')
except HTTPError:
self.test_list = get_client().get_list('open_list.example.com')
# Set subscription policy to open
settings = self.test_list.settings
settings['subscription_policy'] = 'open'
settings.save()
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'pwd')
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.test_list = self.domain.create_list('open_list')
except HTTPError:
self.test_list = get_client().get_list('open_list.example.com')
# Set subscription policy to open
settings = self.test_list.settings
settings['subscription_policy'] = 'open'
settings.save()
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'pwd')
def list_subscription_requests(request, list_id):
"""Shows a list of held messages.
"""
try:
m_list = utils.get_client().get_list(list_id)
except MailmanApiError:
return utils.render_api_error(request)
return render_to_response('postorius/lists/subscription_requests.html',
{'list': m_list},
context_instance=RequestContext(request))
def test_new_list_created_with_owner(self):
self.client.login(username='******', password='******')
post_data = {'listname': 'a_new_list',
'mail_host': 'example.com',
'list_owner': '*****@*****.**',
'advertised': 'True',
'description': 'A new list.'}
self.client.post(reverse('list_new'), post_data)
a_new_list = get_client().get_list('*****@*****.**')
self.assertEqual(a_new_list.fqdn_listname, u'*****@*****.**')
self.assertEqual(a_new_list.owners, [u'*****@*****.**'])
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.foo_list = self.domain.create_list('foo')
except HTTPError:
self.foo_list = get_client().get_list('foo.example.com')
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'testpass')
self.superuser = User.objects.create_superuser(
'testsu', '*****@*****.**', 'testpass')
self.owner = User.objects.create_user(
'testowner', '*****@*****.**', 'testpass')
self.moderator = User.objects.create_user(
'testmoderator', '*****@*****.**', 'testpass')
self.foo_list.add_owner('*****@*****.**')
self.foo_list.add_moderator('*****@*****.**')
def setUp(self):
self.mm_client = get_client()
self.client = Client()
try:
self.domain = self.mm_client.create_domain('example.org')
except HTTPError:
self.domain = self.mm_client.get_domain('example.org')
self.domain.create_list('test')
self.test_list = self.mm_client.get_list('*****@*****.**')
User.objects.filter(username='******').delete()
self.superuser = User.objects.create_superuser('su', '*****@*****.**',
'pwd')
def setUp(self):
super(ListMembersOptionsTest, self).setUp()
self.domain = get_client().create_domain('example.com')
self.foo_list = self.domain.create_list('foo')
self.user = User.objects.create_user(
'testuser', '*****@*****.**', 'testpass')
self.superuser = User.objects.create_superuser(
'testsu', '*****@*****.**', 'testpass')
self.owner = User.objects.create_user(
'testowner', '*****@*****.**', 'testpass')
self.moderator = User.objects.create_user(
'testmoderator', '*****@*****.**', 'testpass')
self.foo_list.add_owner('*****@*****.**')
self.foo_list.add_moderator('*****@*****.**')
self.mm_user = get_client().create_user('*****@*****.**', '')
self.mm_user.addresses[0].verify()
self.foo_list.subscribe('*****@*****.**', pre_verified=True,
pre_confirmed=True, pre_approved=True)
self.url = reverse('list_member_options', args=(self.foo_list.list_id,
'*****@*****.**',))
self.url = quote(self.url)
def setUp(self):
self.client = Client()
self.mmclient = get_client()
try:
domain = self.mmclient.create_domain('example.com')
except HTTPError:
domain = self.mmclient.get_domain('example.com')
self.foo_list = domain.create_list('foo')
try:
User.objects.create_user('testuser', '*****@*****.**', 'testpass')
except IntegrityError:
pass
def setUp(self):
self.client = Client()
self.mmclient = get_client()
try:
domain = self.mmclient.create_domain("example.com")
except HTTPError:
domain = self.mmclient.get_domain("example.com")
self.foo_list = domain.create_list("foo")
try:
User.objects.create_user("testuser", "*****@*****.**", "testpass")
except IntegrityError:
pass
def setUp(self):
self.mm_client = get_client()
self.client = Client()
try:
self.domain = self.mm_client.create_domain('example.org')
except HTTPError:
self.domain = self.mm_client.get_domain('example.org')
self.domain.create_list('test')
self.test_list = self.mm_client.get_list('*****@*****.**')
User.objects.filter(username='******').delete()
self.superuser = User.objects.create_superuser(
'su', '*****@*****.**', 'pwd')
def setUp(self):
self.client = Client()
try:
self.domain = get_client().create_domain('example.com')
except HTTPError:
self.domain = get_client().get_domain('example.com')
try:
self.foo_list = self.domain.create_list('foo')
except HTTPError:
self.foo_list = get_client().get_list('foo.example.com')
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testpass')
self.superuser = User.objects.create_superuser('testsu',
'*****@*****.**',
'testpass')
self.owner = User.objects.create_user('testowner', '*****@*****.**',
'testpass')
self.moderator = User.objects.create_user('testmoderator',
'*****@*****.**',
'testpass')
self.foo_list.add_owner('*****@*****.**')
self.foo_list.add_moderator('*****@*****.**')
def create(self, *args, **kwargs):
try:
method = getattr(get_client(), 'create_' + self.resource_name)
return method(*args, **kwargs)
except AttributeError as e:
raise MailmanApiError(e)
except HTTPError as e:
if e.code == 409:
raise MailmanApiError
else:
raise
except MailmanConnectionError:
raise MailmanApiError
def get(self, *args, **kwargs):
try:
method = getattr(get_client(), 'get_' + self.resource_name)
return method(*args, **kwargs)
except AttributeError as e:
raise MailmanApiError(e)
except HTTPError as e:
if e.code == 404:
raise Mailman404Error('Mailman resource could not be found.')
else:
raise
except MailmanConnectionError as e:
raise MailmanApiError(e)
def get(self, *args, **kwargs):
try:
method = getattr(get_client(), 'get_' + self.resource_name)
return method(*args, **kwargs)
except AttributeError as e:
raise MailmanApiError(e)
except HTTPError as e:
if e.code == 404:
raise Mailman404Error('Mailman resource could not be found.')
else:
raise
except MailmanConnectionError as e:
raise MailmanApiError(e)
def create(self, *args, **kwargs):
try:
method = getattr(get_client(), 'create_' + self.resource_name)
return method(*args, **kwargs)
except AttributeError as e:
raise MailmanApiError(e)
except HTTPError as e:
if e.code == 409:
raise MailmanApiError
else:
raise
except MailmanConnectionError:
raise MailmanApiError
def create_mailman_user(sender, **kwargs):
if kwargs.get('created'):
autocreate = False
try:
autocreate = settings.AUTOCREATE_MAILMAN_USER
except AttributeError:
pass
if autocreate:
user = kwargs.get('instance')
client = get_client()
try:
client.create_user(user.email, None, None)
except HTTPError:
pass
def handle(self, *args, **options):
# choose an interpreter
console = None
try:
import IPython
console_fn = IPython.embed
except ImportError:
import code
shell = code.InteractiveConsole(globals())
console_fn = shell.interact
# connect to mailmanclient
client = utils.get_client()
# run the interpreter
console_fn()
def create_mailman_user(sender, **kwargs):
if kwargs.get('created'):
autocreate = False
try:
autocreate = settings.AUTOCREATE_MAILMAN_USER
except AttributeError:
pass
if autocreate:
user = kwargs.get('instance')
client = get_client()
try:
client.create_user(user.email, None, None)
except HTTPError:
pass
def all(self, only_public=False):
try:
objects = getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError as e:
raise MailmanApiError(e)
if only_public:
public = []
for obj in objects:
if obj.settings.get('advertised', False):
public.append(obj)
return public
else:
return objects
def all(self, only_public=False):
try:
objects = getattr(get_client(), self.resource_name_plural)
except AttributeError:
raise MailmanApiError
except MailmanConnectionError as e:
raise MailmanApiError(e)
if only_public:
public = []
for obj in objects:
if obj.settings.get('advertised', False):
public.append(obj)
return public
else:
return objects
def handle(self, *args, **options):
# choose an interpreter
try:
import IPython
console_fn = IPython.embed
except ImportError:
import code
shell = code.InteractiveConsole(globals())
console_fn = shell.interact
# connect to mailmanclient
client = utils.get_client()
# Putting client back in the global scope
globals()['client'] = client
# run the interpreter
console_fn()
def domain_delete(request, domain):
"""Deletes a domain but asks for confirmation first.
"""
if request.method == 'POST':
try:
client = utils.get_client()
client.delete_domain(domain)
messages.success(request,
_('The domain %s has been deleted.' % domain))
return redirect("domain_index")
except HTTPError as e:
messages.error(request,
_('The domain could not be deleted: %s' % e.msg))
return redirect("domain_index")
return render(request, 'postorius/domain/confirm_delete.html',
{'domain': domain})
def user_index(request, page=1, template='postorius/users/index.html'):
"""Show a table of all users.
"""
page = int(page)
error = None
try:
mm_user_page = utils.get_client().get_user_page(25, page)
except MailmanApiError:
return utils.render_api_error(request)
return render_to_response(
template,
{'error': error,
'mm_user_page': mm_user_page,
'mm_user_page_nr': page,
'mm_user_page_previous_nr': page - 1,
'mm_user_page_next_nr': page + 1,
'mm_user_page_show_next': len(mm_user_page) >= 25},
context_instance=RequestContext(request))
def get(self, request, list_id, email):
try:
client = utils.get_client()
mm_member = client.get_member(list_id, email)
mm_list = client.get_list(list_id)
settingsform = UserPreferences(initial=mm_member.preferences)
except MailmanApiError:
return utils.render_api_error(request)
except Mailman404Error:
return render_to_response(
'postorius/lists/memberoptions.html',
{'nolists': 'true'},
context_instance=RequestContext(request))
return render_to_response(
'postorius/lists/memberoptions.html',
{'mm_member': mm_member,
'list': mm_list,
'settingsform': settingsform,
},
context_instance=RequestContext(request))
def get(self, request, fqdn_listname, email):
try:
client = utils.get_client()
mm_member = client.get_member(fqdn_listname, email)
mm_list = client.get_list(fqdn_listname)
settingsform = UserPreferences(initial=mm_member.preferences)
except MailmanApiError:
return utils.render_api_error(request)
except Mailman404Error:
return render_to_response(
'postorius/lists/memberoptions.html',
{'nolists': 'true'},
context_instance=RequestContext(request))
return render_to_response(
'postorius/lists/memberoptions.html',
{'mm_member': mm_member,
'list': mm_list,
'settingsform': settingsform,
},
context_instance=RequestContext(request))
def csv_view(request, list_id):
"""Export all the subscriber in csv
"""
mm_lists = []
try:
client = utils.get_client()
mm_lists = client.get_list(list_id)
except MailmanApiError:
return utils.render_api_error(request)
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = (
'attachment; filename="Subscribers.csv"')
writer = csv.writer(response)
if mm_lists:
for i in mm_lists.members:
writer.writerow([i.email])
return response
def list_archival_options(request, list_id):
"""
Activate or deactivate list archivers.
"""
# Get the list and cache the archivers property.
m_list = utils.get_client().get_list(list_id)
archivers = m_list.archivers
# Process form submission.
if request.method == 'POST':
current = [key for key in archivers.keys() if archivers[key]]
posted = request.POST.getlist('archivers')
# These should be activated
to_activate = [arc for arc in posted if arc not in current]
for arc in to_activate:
archivers[arc] = True
# These should be disabled
to_disable = [arc for arc in current if arc not in posted and
arc in current]
for arc in to_disable:
archivers[arc] = False
# Re-cache list of archivers after update.
archivers = m_list.archivers
# Show success/error messages.
_add_archival_messages(to_activate, to_disable, archivers, request)
# Instantiate form with current archiver data.
initial = {'archivers': [key for key in archivers.keys()
if archivers[key] is True]}
form = ListArchiverForm(initial=initial, archivers=archivers)
return render_to_response('postorius/lists/archival_options.html',
{'list': m_list,
'form': form,
'archivers': archivers},
context_instance=RequestContext(request))
def domain_delete(request, domain):
"""Deletes a domain but asks for confirmation first.
"""
if request.method == 'POST':
try:
client = utils.get_client()
client.delete_domain(domain)
messages.success(request,
_('The domain %s has been deleted.' % domain))
return redirect("domain_index")
except HTTPError as e:
print e.__dict__
messages.error(request,
_('The domain could not be deleted:'
' %s' % e.msg))
return redirect("domain_index")
submit_url = reverse('domain_delete', kwargs={'domain': domain})
return render_to_response('postorius/domain_confirm_delete.html', {
'domain': domain,
'submit_url': submit_url
},
context_instance=RequestContext(request))
