← Back to branch summary

~abompard/postorius/include-sdist

« back to all changes in this revision

Viewing changes to src/postorius/views/list.py

  • Committer: Florian Fuchs
  • Date: 2015-01-19 15:03:09 UTC
  • mfrom: (188.4.2 postorius)
  • Revision ID: flo.fuchs@gmail.com-20150119150309-lcdx9ztq29ejj0ze
* URLs now contains the list-id instead of the fqdn_listname. Contributed by Abhilash Raj (LP: 1201150).
* Added dev_requirements.txt for installation of development dependencies.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/postorius/views/list.py
44
44
    """Display all members of a given list.
45
45
    """
46
46
 
47
 
    def _get_list(self, fqdn_listname, page):
48
 
        m_list = super(ListMembersView, self)._get_list(fqdn_listname, page)
 
47
    def _get_list(self, list_id, page):
 
48
        m_list = super(ListMembersView, self)._get_list(list_id, page)
49
49
        m_list.member_page = m_list.get_member_page(25, page)
50
50
        m_list.member_page_nr = page
51
51
        m_list.member_page_previous_nr = page - 1
54
54
        return m_list
55
55
 
56
56
    @method_decorator(list_owner_required)
57
 
    def post(self, request, fqdn_listname, page=1):
 
57
    def post(self, request, list_id, page=1):
58
58
        if 'owner_email' in request.POST:
59
59
            owner_form = NewOwnerForm(request.POST)
60
60
            if owner_form.is_valid():
88
88
                                  context_instance=RequestContext(request))
89
89
 
90
90
    @method_decorator(list_owner_required)
91
 
    def get(self, request, fqdn_listname, page=1):
 
91
    def get(self, request, list_id, page=1):
92
92
        owner_form = NewOwnerForm()
93
93
        moderator_form = NewModeratorForm()
94
94
        return render_to_response('postorius/lists/members.html',
102
102
    '''View the preferences for a single member of a mailing list'''
103
103
 
104
104
    @method_decorator(list_owner_required)
105
 
    def post(self, request, fqdn_listname, email):
 
105
    def post(self, request, list_id, email):
106
106
        try:
107
107
            client = utils.get_client()
108
 
            mm_member = client.get_member(fqdn_listname, email)
109
 
            mm_list = client.get_list(fqdn_listname)
 
108
            mm_member = client.get_member(list_id, email)
 
109
            mm_list = client.get_list(list_id)
110
110
            preferences_form = UserPreferences(request.POST)
111
111
            if preferences_form.is_valid():
112
112
                preferences = mm_member.preferences
134
134
            context_instance=RequestContext(request))
135
135
 
136
136
    @method_decorator(list_owner_required)
137
 
    def get(self, request, fqdn_listname, email):
 
137
    def get(self, request, list_id, email):
138
138
        try:
139
139
            client = utils.get_client()
140
 
            mm_member = client.get_member(fqdn_listname, email)
141
 
            mm_list = client.get_list(fqdn_listname)
 
140
            mm_member = client.get_member(list_id, email)
 
141
            mm_list = client.get_list(list_id)
142
142
            settingsform = UserPreferences(initial=mm_member.preferences)
143
143
        except MailmanApiError:
144
144
            return utils.render_api_error(request)
162
162
    """
163
163
 
164
164
    @method_decorator(list_owner_required)
165
 
    def get(self, request, fqdn_listname):
 
165
    def get(self, request, list_id):
166
166
        return render_to_response('postorius/lists/metrics.html',
167
167
                                  {'list': self.mailing_list},
168
168
                                  context_instance=RequestContext(request))
173
173
    """Shows common list metrics.
174
174
    """
175
175
 
176
 
    def get(self, request, fqdn_listname):
 
176
    def get(self, request, list_id):
177
177
        user_email = getattr(request.user, 'email', None)
178
178
        userSubscribed = False
179
179
        try:
195
195
    """Subscribe a mailing list."""
196
196
 
197
197
    @method_decorator(login_required)
198
 
    def post(self, request, fqdn_listname):
 
198
    def post(self, request, list_id):
199
199
        try:
200
200
            form = ListSubscribe(request.POST)
201
201
            if form.is_valid():
211
211
            return utils.render_api_error(request)
212
212
        except HTTPError, e:
213
213
            messages.error(request, e.msg)
214
 
        return redirect('list_summary', self.mailing_list.fqdn_listname)
 
214
        return redirect('list_summary', self.mailing_list.list_id)
215
215
 
216
216
 
217
217
class ListUnsubscribeView(MailingListView):
230
230
            return utils.render_api_error(request)
231
231
        except ValueError, e:
232
232
            messages.error(request, e)
233
 
        return redirect('list_summary', self.mailing_list.fqdn_listname)
 
233
        return redirect('list_summary', self.mailing_list.list_id)
234
234
 
235
235
 
236
236
class ListMassSubsribeView(MailingListView):
267
267
                        return utils.render_api_error(request)
268
268
                    except HTTPError, e:
269
269
                        messages.error(request, e)
270
 
        return redirect('mass_subscribe', self.mailing_list.fqdn_listname)
 
270
        return redirect('mass_subscribe', self.mailing_list.list_id)
271
271
 
272
272
 
273
273
def _get_choosable_domains(request):
313
313
                list_settings.save()
314
314
                messages.success(request, _("List created"))
315
315
                return redirect("list_summary",
316
 
                                fqdn_listname=mailing_list.fqdn_listname)
 
316
                                list_id=mailing_list.list_id)
317
317
            # TODO catch correct Error class:
318
318
            except HTTPError, e:
319
319
                return render_to_response(
344
344
        return utils.render_api_error(request)
345
345
    choosable_domains = _get_choosable_domains(request)
346
346
    if request.method == 'POST':
347
 
        return redirect("list_summary", fqdn_listname=request.POST["list"])
 
347
        return redirect("list_summary", list_id=request.POST["list"])
348
348
    else:
349
349
        return render_to_response(template,
350
350
                                  {'error': error,
354
354
 
355
355
 
356
356
@login_required
357
 
def list_subscriptions(request, option=None, fqdn_listname=None,
 
357
def list_subscriptions(request, option=None, list_id=None,
358
358
                       user_email=None,
359
359
                       template='postorius/lists/subscriptions.html',
360
360
                       *args, **kwargs):
369
369
    error = None
370
370
    form_subscribe = None
371
371
    form_unsubscribe = None
372
 
    if request.POST.get('fqdn_listname', ''):
373
 
        fqdn_listname = request.POST.get('fqdn_listname', '')
 
372
    if request.POST.get('list_id', ''):
 
373
        list_id = request.POST.get('list_id', '')
374
374
    # connect REST and catch issues getting the list
375
375
    try:
376
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
376
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
377
377
    except AttributeError, e:
378
378
        return render_to_response('postorius/errors/generic.html',
379
379
                                  {'error': 'Mailman REST API not available.'
444
444
                initial={'fqdn_listname': fqdn_listname,
445
445
                         'email': request.user.username,
446
446
                         'name': 'unsubscribe'})
447
 
    the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
447
    the_list = List.objects.get_or_404(fqdn_listname=list_id)
448
448
    return render_to_response(template,
449
449
                              {'form_subscribe': form_subscribe,
450
450
                               'form_unsubscribe': form_unsubscribe,
455
455
 
456
456
 
457
457
@list_owner_required
458
 
def list_delete(request, fqdn_listname):
 
458
def list_delete(request, list_id):
459
459
    """Deletes a list but asks for confirmation first.
460
460
    """
461
461
    try:
462
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
462
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
463
463
    except MailmanApiError:
464
464
        return utils.render_api_error(request)
465
465
    if request.method == 'POST':
467
467
        return redirect("list_index")
468
468
    else:
469
469
        submit_url = reverse('list_delete',
470
 
                             kwargs={'fqdn_listname': fqdn_listname})
 
470
                             kwargs={'list_id': list_id})
471
471
        cancel_url = reverse('list_index',)
472
472
        return render_to_response(
473
473
            'postorius/lists/confirm_delete.html',
477
477
 
478
478
 
479
479
@list_owner_required
480
 
def list_held_messages(request, fqdn_listname):
 
480
def list_held_messages(request, list_id):
481
481
    """Shows a list of held messages.
482
482
    """
483
483
    try:
484
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
484
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
485
485
    except MailmanApiError:
486
486
        return utils.render_api_error(request)
487
487
    return render_to_response('postorius/lists/held_messages.html',
490
490
 
491
491
 
492
492
@list_owner_required
493
 
def accept_held_message(request, fqdn_listname, msg_id):
 
493
def accept_held_message(request, list_id, msg_id):
494
494
    """Accepts a held message.
495
495
    """
496
496
    try:
497
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
497
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
498
498
        the_list.accept_message(msg_id)
499
499
    except MailmanApiError:
500
500
        return utils.render_api_error(request)
501
501
    except HTTPError, e:
502
502
        messages.error(request, e.msg)
503
 
        return redirect('list_held_messages', the_list.fqdn_listname)
 
503
        return redirect('list_held_messages', the_list.list_id)
504
504
    messages.success(request, 'The message has been accepted.')
505
 
    return redirect('list_held_messages', the_list.fqdn_listname)
 
505
    return redirect('list_held_messages', the_list.list_id)
506
506
 
507
507
 
508
508
@list_owner_required
509
 
def discard_held_message(request, fqdn_listname, msg_id):
 
509
def discard_held_message(request, list_id, msg_id):
510
510
    """Accepts a held message.
511
511
    """
512
512
    try:
513
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
513
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
514
514
        the_list.discard_message(msg_id)
515
515
    except MailmanApiError:
516
516
        return utils.render_api_error(request)
517
517
    except HTTPError, e:
518
518
        messages.error(request, e.msg)
519
 
        return redirect('list_held_messages', the_list.fqdn_listname)
 
519
        return redirect('list_held_messages', the_list.list_id)
520
520
    messages.success(request, 'The message has been discarded.')
521
 
    return redirect('list_held_messages', the_list.fqdn_listname)
 
521
    return redirect('list_held_messages', the_list.list_id)
522
522
 
523
523
 
524
524
@list_owner_required
525
 
def defer_held_message(request, fqdn_listname, msg_id):
 
525
def defer_held_message(request, list_id, msg_id):
526
526
    """Accepts a held message.
527
527
    """
528
528
    try:
529
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
529
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
530
530
        the_list.defer_message(msg_id)
531
531
    except MailmanApiError:
532
532
        return utils.render_api_error(request)
533
533
    except HTTPError, e:
534
534
        messages.error(request, e.msg)
535
 
        return redirect('list_held_messages', the_list.fqdn_listname)
 
535
        return redirect('list_held_messages', the_list.list_id)
536
536
    messages.success(request, 'The message has been defered.')
537
 
    return redirect('list_held_messages', the_list.fqdn_listname)
 
537
    return redirect('list_held_messages', the_list.list_id)
538
538
 
539
539
 
540
540
@list_owner_required
541
 
def reject_held_message(request, fqdn_listname, msg_id):
 
541
def reject_held_message(request, list_id, msg_id):
542
542
    """Accepts a held message.
543
543
    """
544
544
    try:
545
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
545
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
546
546
        the_list.reject_message(msg_id)
547
547
    except MailmanApiError:
548
548
        return utils.render_api_error(request)
549
549
    except HTTPError, e:
550
550
        messages.error(request, e.msg)
551
 
        return redirect('list_held_messages', the_list.fqdn_listname)
 
551
        return redirect('list_held_messages', the_list.list_id)
552
552
    messages.success(request, 'The message has been rejected.')
553
 
    return redirect('list_held_messages', the_list.fqdn_listname)
 
553
    return redirect('list_held_messages', the_list.list_id)
554
554
 
555
555
 
556
556
@list_owner_required
557
 
def list_settings(request, fqdn_listname=None, visible_section=None,
 
557
def list_settings(request, list_id=None, visible_section=None,
558
558
                  visible_option=None,
559
559
                  template='postorius/lists/settings.html'):
560
560
    """
572
572
        visible_section = 'List Identity'
573
573
    form_sections = []
574
574
    try:
575
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
575
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
576
576
    except MailmanApiError:
577
577
        return utils.render_api_error(request)
578
578
    # collect all Form sections for the links:
623
623
 
624
624
 
625
625
@user_passes_test(lambda u: u.is_superuser)
626
 
def remove_role(request, fqdn_listname=None, role=None, address=None,
 
626
def remove_role(request, list_id=None, role=None, address=None,
627
627
                template='postorius/lists/confirm_remove_role.html'):
628
628
    """Removes a list moderator or owner.
629
629
    """
630
630
    try:
631
 
        the_list = List.objects.get_or_404(fqdn_listname=fqdn_listname)
 
631
        the_list = List.objects.get_or_404(fqdn_listname=list_id)
632
632
    except MailmanApiError:
633
633
        return utils.render_api_error(request)
634
634
 
636
636
        if address not in the_list.owners:
637
637
            messages.error(request,
638
638
                           _('The user {} is not an owner'.format(address)))
639
 
            return redirect("list_members", the_list.fqdn_listname)
 
639
            return redirect("list_members", the_list.list_id)
640
640
    elif role == 'moderator':
641
641
        if address not in the_list.moderators:
642
642
            messages.error(request,
643
643
                           _('The user {} is not a moderator'.format(address)))
644
 
            return redirect("list_members", the_list.fqdn_listname)
 
644
            return redirect("list_members", the_list.list_id)
645
645
 
646
646
    if request.method == 'POST':
647
647
        try:
651
651
        except HTTPError as e:
652
652
            messages.error(request, _('The {0} could not be removed:'
653
653
                                      ' {1}'.format(role, e.msg)))
654
 
            return redirect("list_members", the_list.fqdn_listname)
 
654
            return redirect("list_members", the_list.list_id)
655
655
        messages.success(request,
656
656
                         _('The user {0} has been removed as {1}.'
657
657
                           .format(address, role)))
658
 
        return redirect("list_members", the_list.fqdn_listname)
 
658
        return redirect("list_members", the_list.list_id)
659
659
 
660
660
    return render_to_response(template,
661
661
                              {'role': role, 'address': address,
662
 
                               'fqdn_listname': the_list.fqdn_listname},
 
662
                               'list_id': the_list.list_id},
663
663
                              context_instance=RequestContext(request))