Merge branch 'private_mailman_lists' into 'master'

Private mailman lists Only show public lists by default. Private lists are only visible if user if a member of that list. That applies to /dashboard /archives/thread and /accounts/username pages. So you cannot view a collaboration of an user in a private-list in their profile if you are not also in the privatelist. Note: You'll need mailman-api running to see this functionality. The tests uses mocked data from the mailman-api.

Merge branch 'private_mailman_lists' into 'master'
Private mailman lists Only show public lists by default. Private lists are only visible if user if a member of that list. That applies to /dashboard /archives/thread and /accounts/username pages. So you cannot view a collaboration of an user in a private-list in their profile if you are not also in the privatelist. Note: You'll need mailman-api running to see this functionality. The tests uses mocked data from the mailman-api.
Sergio Oliveira
2 parents 256ed785 058dc7b0
Showing 14 changed files with 423 additions and 51 deletions Show diff stats
colab/accounts/utils/mailman.py
colab/accounts/views.py
colab/home/views.py
colab/search/tests.py
colab/search/utils.py
colab/super_archives/fixtures/mailinglistdata.json
colab/super_archives/management/commands/import_emails.py
colab/super_archives/management/commands/message.py
colab/super_archives/migrations/0002_mailinglist_is_private.py
colab/super_archives/models.py
colab/super_archives/search_indexes.py
colab/super_archives/tests/__init__.py
colab/super_archives/tests/test_privatelist.py
colab/super_archives/views.py
@@ -38,7 +38,7 @@ def unsubscribe(listname, address):
 def update_subscription(address, lists):
-    current_lists = address_lists(address)
+    current_lists = mailing_lists(address=address)
     for maillist in current_lists:
         if maillist not in lists:
@@ -49,14 +49,11 @@ def update_subscription(address, lists):
             subscribe(maillist, address)
-def address_lists(address, description=''):
+def mailing_lists(**kwargs):
     url = get_url()
-    params = {'address': address,
-              'description': description}
-
     try:
-        lists = requests.get(url, timeout=TIMEOUT, params=params)
+        lists = requests.get(url, timeout=TIMEOUT, params=kwargs)
     except:
         LOGGER.exception('Unable to list mailing lists')
         return []
@@ -64,15 +61,22 @@ def address_lists(address, description=&#39;&#39;):
     return lists.json()
-def all_lists(*args, **kwargs):
-    return address_lists('', *args, **kwargs)
+def is_private_list(name):
+    try:
+        return dict(all_lists(private=True))[name]
+    except KeyError:
+        return []
+
+
+def all_lists(**kwargs):
+    return mailing_lists(**kwargs)
 def user_lists(user):
     list_set = set()
     for email in user.emails.values_list('address', flat=True):
-        list_set.update(address_lists(email))
+        list_set.update(mailing_lists(address=email))
     return tuple(list_set)
@@ -97,3 +101,16 @@ def list_users(listname):
         return []
     return users.json()
+
+
+def get_user_mailinglists(user):
+    lists_for_user = []
+    emails = ''
+
+    if user:
+        emails = user.emails.values_list('address', flat=True)
+
+    for email in emails:
+        lists_for_user.extend(mailing_lists(address=email))
+
+    return lists_for_user
@@ -15,9 +15,10 @@ from django.views.generic import DetailView, UpdateView, TemplateView
 from conversejs import xmpp
 from conversejs.models import XMPPAccount
-from colab.super_archives.models import (EmailAddress, Message,
+from colab.super_archives.models import (EmailAddress,
                                          EmailAddressValidation)
-from colab.search.utils import get_collaboration_data
+from colab.search.utils import get_collaboration_data, get_visible_threads
+from colab.accounts.models import User
 from .forms import (UserCreationForm, UserForm, ListsForm,
                     UserUpdateForm, ChangeXMPPPasswordForm)
@@ -60,12 +61,17 @@ class UserProfileDetailView(UserProfileBaseMixin, DetailView):
     template_name = 'accounts/user_detail.html'
     def get_context_data(self, **kwargs):
-        user = self.object
+        profile_user = self.object
         context = {}
         count_types = OrderedDict()
-        collaborations, count_types_extras = get_collaboration_data(user)
+        logged_user = None
+        if self.request.user.is_authenticated():
+            logged_user = User.objects.get(username=self.request.user)
+
+        collaborations, count_types_extras = get_collaboration_data(
+            logged_user, profile_user)
         collaborations.sort(key=lambda elem: elem.modified, reverse=True)
@@ -74,16 +80,13 @@ class UserProfileDetailView(UserProfileBaseMixin, DetailView):
         context['type_count'] = count_types
         context['results'] = collaborations[:10]
-        email_pks = [addr.pk for addr in user.emails.iterator()]
-        query = Message.objects.filter(from_address__in=email_pks)
-        query = query.order_by('-received_time')
-        context['emails'] = query[:10]
+        query = get_visible_threads(logged_user, profile_user)
+        context['emails'] = query.order_by('-received_time')[:10]
-        messages = Message.objects.filter(from_address__user__pk=user.pk)
         count_by = 'thread__mailinglist__name'
-        context['list_activity'] = dict(messages.values_list(count_by)
-                                                .annotate(Count(count_by))
-                                                .order_by(count_by))
+        context['list_activity'] = dict(query.values_list(count_by)
+                                        .annotate(Count(count_by))
+                                        .order_by(count_by))
         context.update(kwargs)
         return super(UserProfileDetailView, self).get_context_data(**context)
@@ -185,7 +188,7 @@ class ManageUserSubscriptionsView(UserProfileBaseMixin, DetailView):
         for email in emails:
             lists = []
-            lists_for_address = mailman.address_lists(email)
+            lists_for_address = mailman.mailing_lists(address=email)
             for listname, description in all_lists:
                 if listname in lists_for_address:
                     checked = True
@@ -4,23 +4,45 @@ from django.http import HttpResponse, Http404
 from colab.search.utils import get_collaboration_data
 from colab.super_archives.models import Thread
+from colab.accounts.utils import mailman
+from colab.accounts.models import User
+
+
+def get_user_threads(threads, lists_for_user, key):
+    visible_threads = []
+    for t in threads:
+        if not t.mailinglist.is_private or \
+           t.mailinglist.name in lists_for_user:
+                visible_threads.append(key(t))
+
+    return visible_threads
 def dashboard(request):
     """Dashboard page"""
-    highest_score_threads = Thread.highest_score.all()[:6]
+    highest_score_threads = Thread.highest_score.all()
+
+    all_threads = Thread.objects.all()
+    latest_threads = []
+    lists_for_user = []
-    hottest_threads = [t.latest_message for t in highest_score_threads]
+    user = None
+    if request.user.is_authenticated():
+        user = User.objects.get(username=request.user)
+        lists_for_user = mailman.get_user_mailinglists(user)
-    latest_threads = Thread.objects.all()[:6]
+    latest_threads = get_user_threads(
+        all_threads, lists_for_user, lambda t: t)
+    hottest_threads = get_user_threads(
+        highest_score_threads, lists_for_user, lambda t: t.latest_message)
-    latest_results, count_types = get_collaboration_data()
+    latest_results, count_types = get_collaboration_data(user)
     latest_results.sort(key=lambda elem: elem.modified, reverse=True)
     context = {
         'hottest_threads': hottest_threads[:6],
-        'latest_threads': latest_threads,
+        'latest_threads': latest_threads[:6],
         'type_count': count_types,
         'latest_results': latest_results[:6],
     }
@@ -13,7 +13,7 @@ class SearchViewTest(TestCase):
         self.client = Client()
     def tearDown(self):
-        call_command('clear_index', interactive=False,verbosity=0)
+        call_command('clear_index', interactive=False, verbosity=0)
     def test_search_thread(self):
         request = self.client.get('/search/?q=thread')
@@ -6,11 +6,40 @@ from collections import OrderedDict
 from django.core.cache import cache
 from django.utils.translation import ugettext as _
 from django.conf import settings
+from django.db.models import Q as Condition
+
 from colab.super_archives.models import Thread, Message
 from colab.proxy.utils.models import Collaboration
+from colab.accounts.utils import mailman
+
+
+def get_visible_threads_queryset(logged_user):
+    queryset = Thread.objects
+    lists_for_user = []
+    if logged_user:
+        lists_for_user = mailman.get_user_mailinglists(logged_user)
+
+    user_lists = Condition(mailinglist__name__in=lists_for_user)
+    public_lists = Condition(mailinglist__is_private=False)
+    queryset = Thread.objects.filter(user_lists | public_lists)
+
+    return queryset
+
+
+def get_visible_threads(logged_user, filter_by_user=None):
+    thread_qs = get_visible_threads_queryset(logged_user)
+    if filter_by_user:
+        message_qs = Message.objects.filter(thread__in=thread_qs)
+        messages = message_qs.filter(
+            from_address__user__pk=filter_by_user.pk)
+    else:
+        latest_threads = thread_qs.all()
+        messages = [t.latest_message for t in latest_threads]
+
+    return messages
-def get_collaboration_data(filter_by_user=None):
+def get_collaboration_data(logged_user, filter_by_user=None):
     latest_results = []
     count_types = cache.get('home_chart')
     populate_count_types = False
@@ -18,14 +47,10 @@ def get_collaboration_data(filter_by_user=None):
     if count_types is None:
         populate_count_types = True
         count_types = OrderedDict()
-        count_types[_('Emails')] = Thread.objects.count()
+        visible_threads = get_visible_threads(logged_user)
+        count_types[_('Emails')] = len(visible_threads)
-    if filter_by_user:
-        messages = Message.objects.filter(
-            from_address__user__pk=filter_by_user.pk)
-    else:
-        latest_threads = Thread.objects.all()[:6]
-        messages = [t.latest_message for t in latest_threads]
+    messages = get_visible_threads(logged_user, filter_by_user)
     latest_results.extend(messages)
@@ -0,0 +1,186 @@
+[
+  {
+    "fields": {
+      "last_name": "Jar",
+      "webpage": null,
+      "twitter": null,
+      "is_staff": false,
+      "user_permissions": [
+        
+      ],
+      "date_joined": "2015-02-24T21:10:35.004Z",
+      "google_talk": null,
+      "first_name": "Gust",
+      "is_superuser": false,
+      "last_login": "2015-02-26T17:56:13.378Z",
+      "verification_hash": null,
+      "role": null,
+      "email": "gustmax@hotmail.com",
+      "username": "gustmax",
+      "bio": null,
+      "needs_update": false,
+      "is_active": true,
+      "facebook": null,
+      "groups": [
+        
+      ],
+      "password": "pbkdf2_sha256$12000$ez83ccNOUQZk$vYT/QcYMukXZ7D7L1qQPyYlzCUEEEF20J7/Xjef0Rqg=",
+      "institution": null,
+      "github": null,
+      "modified": "2015-02-24T21:11:22.323Z"
+    },
+    "model": "accounts.user",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "real_name": "",
+      "user": 1,
+      "md5": "ed8f47ae6048f8d4456c0554578f53ff",
+      "address": "gustmax@hotmail.com"
+    },
+    "model": "super_archives.emailaddress",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "description": "",
+      "email": "",
+      "logo": "",
+      "last_imported_index": 0,
+      "is_private": true,
+      "name": "mailman"
+    },
+    "model": "super_archives.mailinglist",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "description": "",
+      "email": "",
+      "logo": "",
+      "last_imported_index": 0,
+      "is_private": false,
+      "name": "lista"
+    },
+    "model": "super_archives.mailinglist",
+    "pk": 2
+  },
+  {
+    "fields": {
+      "description": "",
+      "email": "",
+      "logo": "",
+      "last_imported_index": 0,
+      "is_private": true,
+      "name": "privatelist"
+    },
+    "model": "super_archives.mailinglist",
+    "pk": 3
+  },
+  {
+    "fields": {
+      "spam": false,
+      "subject_token": "no-subject",
+      "mailinglist": 1,
+      "score": 34,
+      "latest_message": 1
+    },
+    "model": "super_archives.thread",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "spam": false,
+      "subject_token": "no-subject",
+      "mailinglist": 2,
+      "score": 34,
+      "latest_message": 2
+    },
+    "model": "super_archives.thread",
+    "pk": 2
+  },
+  {
+    "fields": {
+      "spam": false,
+      "subject_token": "no-subject",
+      "mailinglist": 3,
+      "score": 33,
+      "latest_message": 3
+    },
+    "model": "super_archives.thread",
+    "pk": 3
+  },
+  {
+    "fields": {
+      "body": "lista Mailman email",
+      "received_time": "2015-02-24T14:23:42Z",
+      "from_address": 1,
+      "thread": 1,
+      "spam": false,
+      "subject_clean": "(no subject)",
+      "message_id": "<20150224142347.9ED2419A5B0@localhost.localdomain>",
+      "subject": "[Mailman] (no subject)"
+    },
+    "model": "super_archives.message",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "body": "nada",
+      "received_time": "2015-02-24T14:15:39Z",
+      "from_address": 1,
+      "thread": 2,
+      "spam": false,
+      "subject_clean": "(no subject)",
+      "message_id": "<20150224141545.1AECA19A5A0@localhost.localdomain>",
+      "subject": "[Lista] (no subject)"
+    },
+    "model": "super_archives.message",
+    "pk": 2
+  },
+  {
+    "fields": {
+      "body": "Mensagem da lista privada nada",
+      "received_time": "2015-02-24T14:15:39Z",
+      "from_address": 1,
+      "thread": 3,
+      "spam": false,
+      "subject_clean": "(no subject)",
+      "message_id": "<20150224141545.1AECA19A5A0@localhost.localdomain>",
+      "subject": "[PrivateList] (no subject)"
+    },
+    "model": "super_archives.message",
+    "pk": 3
+  },
+  {
+    "fields": {
+      "text": "lista Mailman email\n",
+      "message": 1,
+      "is_reply": false,
+      "order": 0
+    },
+    "model": "super_archives.messageblock",
+    "pk": 1
+  },
+  {
+    "fields": {
+      "text": "nada\n",
+      "message": 2,
+      "is_reply": false,
+      "order": 0
+    },
+    "model": "super_archives.messageblock",
+    "pk": 2
+  },
+  {
+    "fields": {
+      "text": "Mensagem da lista privada nada\n",
+      "message": 3,
+      "is_reply": false,
+      "order": 0
+    },
+    "model": "super_archives.messageblock",
+    "pk": 3
+  }
+]
@@ -295,3 +295,7 @@ class Command(BaseCommand, object):
             raise
         finally:
             os.remove(self.lock_file)
+
+        for mlist in MailingList.objects.all():
+            mlist.update_privacy()
+            mlist.save()
@@ -79,7 +79,7 @@ class Message(mailbox.mboxMessage):
             return body.strip()
     def get_received_datetime(self):
-        if self not in ('Received'):
+        if 'Received' not in self:
             return None
         # The time received should always be the last element
         #   in the `Received` attribute from the message headers
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('super_archives', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='mailinglist',
+            name='is_private',
+            field=models.BooleanField(default=False),
+            preserve_default=True,
+        ),
+    ]
@@ -19,6 +19,7 @@ from hitcounter.models import HitCounterModelMixin
 from .managers import NotSpamManager, MostVotedManager, HighestScore
 from .utils import blocks, email
 from .utils.etiquetador import etiquetador
+from colab.accounts.utils import mailman
 def get_validation_key():
@@ -79,6 +80,10 @@ class MailingList(models.Model):
     description = models.TextField()
     logo = models.FileField(upload_to='list_logo')  # TODO
     last_imported_index = models.IntegerField(default=0)
+    is_private = models.BooleanField(default=False)
+
+    def update_privacy(self):
+        self.is_private = mailman.is_private_list(self.name)
     def get_absolute_url(self):
         params = {
@@ -85,10 +85,12 @@ class ThreadIndex(BaseIndex, indexes.Indexable):
         return u'thread'
     def index_queryset(self, using=None):
-        return self.get_model().objects.filter(
-            spam=False
+        elements = self.get_model().objects.filter(
+            spam=False, mailinglist__is_private=False
         ).exclude(subject_token='')
+        return elements
+
     def get_boost(self, obj):
         boost = super(ThreadIndex, self).get_boost(obj)
@@ -0,0 +1,66 @@
+# -*- coding:utf-8 -*-
+import mock
+
+from colab.accounts.utils import mailman
+from django.test import TestCase,  Client
+
+
+class ArchivesViewTest(TestCase):
+
+    fixtures = ['mailinglistdata.json']
+
+    def setUp(self):
+        self.client = Client()
+
+    def authenticate_user(self):
+        self.client.login(username='gustmax', password='1234')
+
+    def test_see_only_private_list_if_member(self):
+        mailman.get_user_mailinglists = mock.Mock(
+            return_value="['privatelist']")
+
+        self.authenticate_user()
+        request = self.client.get('/archives/thread/')
+
+        list_data = request.context['lists']
+
+        self.assertEqual('lista', list_data[0][0])
+        self.assertEqual('privatelist', list_data[1][0])
+        self.assertEqual(2,  len(list_data))
+
+    def test_see_only_public_if_not_logged_in(self):
+        request = self.client.get('/archives/thread/')
+
+        list_data = request.context['lists']
+
+        self.assertEqual('lista', list_data[0][0])
+        self.assertEqual(1,  len(list_data))
+
+    def test_see_private_thread_in_dashboard_if_member(self):
+        mailman.get_user_mailinglists = mock.Mock(
+            return_value="['privatelist']")
+
+        self.authenticate_user()
+        request = self.client.get('/dashboard')
+
+        latest_threads = request.context['latest_threads']
+        hottest_threads = request.context['hottest_threads']
+
+        self.assertEqual(2, len(latest_threads))
+        self.assertEqual(2, len(hottest_threads))
+
+    def test_dont_see_private_thread_if_logged_out(self):
+        request = self.client.get('/dashboard')
+
+        latest_threads = request.context['latest_threads']
+        hottest_threads = request.context['hottest_threads']
+
+        self.assertEqual(1, len(latest_threads))
+        self.assertEqual(1, len(hottest_threads))
+
+    def test_dont_see_private_threads_in_profile_if_logged_out(self):
+        request = self.client.get('/account/gustmax')
+
+        emails = request.context['emails']
+
+        self.assertEqual(1, len(emails))
@@ -12,7 +12,7 @@ from django.contrib import messages
 from django.db import IntegrityError
 from django.views.generic import View
 from django.utils.translation import ugettext as _
-from django.core.exceptions import ObjectDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist, PermissionDenied
 from django.utils.decorators import method_decorator
 from django.contrib.auth.decorators import login_required
 from django.shortcuts import render, redirect, get_object_or_404
@@ -31,6 +31,18 @@ class ThreadView(View):
         thread = get_object_or_404(Thread, subject_token=thread_token,
                                    mailinglist__name=mailinglist)
+
+        all_privates = dict(mailman.all_lists(private=True))
+        if all_privates[thread.mailinglist.name]:
+            if not request.user.is_authenticated():
+                raise PermissionDenied
+            else:
+                user = User.objects.get(username=request.user)
+                emails = user.emails.values_list('address', flat=True)
+                lists_for_user = mailman.get_user_mailinglists(user)
+                if thread.mailinglist.name not in lists_for_user:
+                    raise PermissionDenied
+
         thread.hit(request)
         try:
@@ -122,21 +134,31 @@ class ThreadDashboardView(View):
     def get(self, request):
         MAX = 6
         context = {}
-        all_lists = mailman.all_lists(description=True)
+
+        all_privates = {}
+        private_mailinglist = MailingList.objects.filter(is_private=True)
+        for mailinglist in private_mailinglist:
+            all_privates[mailinglist.name] = True
         context['lists'] = []
+        lists_for_user = []
+        if request.user.is_authenticated():
+            user = User.objects.get(username=request.user)
+            lists_for_user = mailman.get_user_mailinglists(user)
+
         for list_ in MailingList.objects.order_by('name'):
-            context['lists'].append((
-                list_.name,
-                mailman.get_list_description(list_.name, all_lists),
-                list_.thread_set.filter(spam=False).order_by(
-                    '-latest_message__received_time'
-                )[:MAX],
-                [t.latest_message for t in Thread.highest_score.filter(
-                    mailinglist__name=list_.name)[:MAX]],
-                len(mailman.list_users(list_.name)),
-            ))
+            if list_.name not in all_privates or list_.name in lists_for_user:
+                context['lists'].append((
+                    list_.name,
+                    mailman.get_list_description(list_.name),
+                    list_.thread_set.filter(spam=False).order_by(
+                        '-latest_message__received_time'
+                    )[:MAX],
+                    [t.latest_message for t in Thread.highest_score.filter(
+                        mailinglist__name=list_.name)[:MAX]],
+                    len(mailman.list_users(list_.name)),
+                ))
         return render(request, 'superarchives/thread-dashboard.html', context)
	@@ -13,7 +13,7 @@ class SearchViewTest(TestCase):		@@ -13,7 +13,7 @@ class SearchViewTest(TestCase):
13	self.client = Client()	13	self.client = Client()
14		14
15	def tearDown(self):	15	def tearDown(self):
16	- call_command('clear_index', interactive=False,verbosity=0)	16	+ call_command('clear_index', interactive=False, verbosity=0)
17		17
18	def test_search_thread(self):	18	def test_search_thread(self):
19	request = self.client.get('/search/?q=thread')	19	request = self.client.get('/search/?q=thread')
	@@ -6,11 +6,40 @@ from collections import OrderedDict		@@ -6,11 +6,40 @@ from collections import OrderedDict
6	from django.core.cache import cache	6	from django.core.cache import cache
7	from django.utils.translation import ugettext as _	7	from django.utils.translation import ugettext as _
8	from django.conf import settings	8	from django.conf import settings
		9	+from django.db.models import Q as Condition
		10	+
9	from colab.super_archives.models import Thread, Message	11	from colab.super_archives.models import Thread, Message
10	from colab.proxy.utils.models import Collaboration	12	from colab.proxy.utils.models import Collaboration
		13	+from colab.accounts.utils import mailman
		14	+
		15	+
		16	+def get_visible_threads_queryset(logged_user):
		17	+ queryset = Thread.objects
		18	+ lists_for_user = []
		19	+ if logged_user:
		20	+ lists_for_user = mailman.get_user_mailinglists(logged_user)
		21	+
		22	+ user_lists = Condition(mailinglist__name__in=lists_for_user)
		23	+ public_lists = Condition(mailinglist__is_private=False)
		24	+ queryset = Thread.objects.filter(user_lists \| public_lists)
		25	+
		26	+ return queryset
		27	+
		28	+
		29	+def get_visible_threads(logged_user, filter_by_user=None):
		30	+ thread_qs = get_visible_threads_queryset(logged_user)
		31	+ if filter_by_user:
		32	+ message_qs = Message.objects.filter(thread__in=thread_qs)
		33	+ messages = message_qs.filter(
		34	+ from_address__user__pk=filter_by_user.pk)
		35	+ else:
		36	+ latest_threads = thread_qs.all()
		37	+ messages = [t.latest_message for t in latest_threads]
		38	+
		39	+ return messages
11		40
12		41
13	-def get_collaboration_data(filter_by_user=None):	42	+def get_collaboration_data(logged_user, filter_by_user=None):
14	latest_results = []	43	latest_results = []
15	count_types = cache.get('home_chart')	44	count_types = cache.get('home_chart')
16	populate_count_types = False	45	populate_count_types = False
	@@ -18,14 +47,10 @@ def get_collaboration_data(filter_by_user=None):		@@ -18,14 +47,10 @@ def get_collaboration_data(filter_by_user=None):
18	if count_types is None:	47	if count_types is None:
19	populate_count_types = True	48	populate_count_types = True
20	count_types = OrderedDict()	49	count_types = OrderedDict()
21	- count_types[_('Emails')] = Thread.objects.count()	50	+ visible_threads = get_visible_threads(logged_user)
		51	+ count_types[_('Emails')] = len(visible_threads)
22		52
23	- if filter_by_user:
24	- messages = Message.objects.filter(
25	- from_address__user__pk=filter_by_user.pk)
26	- else:
27	- latest_threads = Thread.objects.all()[:6]
28	- messages = [t.latest_message for t in latest_threads]	53	+ messages = get_visible_threads(logged_user, filter_by_user)
29		54
30	latest_results.extend(messages)	55	latest_results.extend(messages)
31		56
@@ -0,0 +1,186 @@		@@ -0,0 +1,186 @@
	1	+[
	2	+ {
	3	+ "fields": {
	4	+ "last_name": "Jar",
	5	+ "webpage": null,
	6	+ "twitter": null,
	7	+ "is_staff": false,
	8	+ "user_permissions": [
	9	+
	10	+ ],
	11	+ "date_joined": "2015-02-24T21:10:35.004Z",
	12	+ "google_talk": null,
	13	+ "first_name": "Gust",
	14	+ "is_superuser": false,
	15	+ "last_login": "2015-02-26T17:56:13.378Z",
	16	+ "verification_hash": null,
	17	+ "role": null,
	18	+ "email": "gustmax@hotmail.com",
	19	+ "username": "gustmax",
	20	+ "bio": null,
	21	+ "needs_update": false,
	22	+ "is_active": true,
	23	+ "facebook": null,
	24	+ "groups": [
	25	+
	26	+ ],
	27	+ "password": "pbkdf2_sha256$12000$ez83ccNOUQZk$vYT/QcYMukXZ7D7L1qQPyYlzCUEEEF20J7/Xjef0Rqg=",
	28	+ "institution": null,
	29	+ "github": null,
	30	+ "modified": "2015-02-24T21:11:22.323Z"
	31	+ },
	32	+ "model": "accounts.user",
	33	+ "pk": 1
	34	+ },
	35	+ {
	36	+ "fields": {
	37	+ "real_name": "",
	38	+ "user": 1,
	39	+ "md5": "ed8f47ae6048f8d4456c0554578f53ff",
	40	+ "address": "gustmax@hotmail.com"
	41	+ },
	42	+ "model": "super_archives.emailaddress",
	43	+ "pk": 1
	44	+ },
	45	+ {
	46	+ "fields": {
	47	+ "description": "",
	48	+ "email": "",
	49	+ "logo": "",
	50	+ "last_imported_index": 0,
	51	+ "is_private": true,
	52	+ "name": "mailman"
	53	+ },
	54	+ "model": "super_archives.mailinglist",
	55	+ "pk": 1
	56	+ },
	57	+ {
	58	+ "fields": {
	59	+ "description": "",
	60	+ "email": "",
	61	+ "logo": "",
	62	+ "last_imported_index": 0,
	63	+ "is_private": false,
	64	+ "name": "lista"
	65	+ },
	66	+ "model": "super_archives.mailinglist",
	67	+ "pk": 2
	68	+ },
	69	+ {
	70	+ "fields": {
	71	+ "description": "",
	72	+ "email": "",
	73	+ "logo": "",
	74	+ "last_imported_index": 0,
	75	+ "is_private": true,
	76	+ "name": "privatelist"
	77	+ },
	78	+ "model": "super_archives.mailinglist",
	79	+ "pk": 3
	80	+ },
	81	+ {
	82	+ "fields": {
	83	+ "spam": false,
	84	+ "subject_token": "no-subject",
	85	+ "mailinglist": 1,
	86	+ "score": 34,
	87	+ "latest_message": 1
	88	+ },
	89	+ "model": "super_archives.thread",
	90	+ "pk": 1
	91	+ },
	92	+ {
	93	+ "fields": {
	94	+ "spam": false,
	95	+ "subject_token": "no-subject",
	96	+ "mailinglist": 2,
	97	+ "score": 34,
	98	+ "latest_message": 2
	99	+ },
	100	+ "model": "super_archives.thread",
	101	+ "pk": 2
	102	+ },
	103	+ {
	104	+ "fields": {
	105	+ "spam": false,
	106	+ "subject_token": "no-subject",
	107	+ "mailinglist": 3,
	108	+ "score": 33,
	109	+ "latest_message": 3
	110	+ },
	111	+ "model": "super_archives.thread",
	112	+ "pk": 3
	113	+ },
	114	+ {
	115	+ "fields": {
	116	+ "body": "lista Mailman email",
	117	+ "received_time": "2015-02-24T14:23:42Z",
	118	+ "from_address": 1,
	119	+ "thread": 1,
	120	+ "spam": false,
	121	+ "subject_clean": "(no subject)",
	122	+ "message_id": "<20150224142347.9ED2419A5B0@localhost.localdomain>",
	123	+ "subject": "[Mailman] (no subject)"
	124	+ },
	125	+ "model": "super_archives.message",
	126	+ "pk": 1
	127	+ },
	128	+ {
	129	+ "fields": {
	130	+ "body": "nada",
	131	+ "received_time": "2015-02-24T14:15:39Z",
	132	+ "from_address": 1,
	133	+ "thread": 2,
	134	+ "spam": false,
	135	+ "subject_clean": "(no subject)",
	136	+ "message_id": "<20150224141545.1AECA19A5A0@localhost.localdomain>",
	137	+ "subject": "[Lista] (no subject)"
	138	+ },
	139	+ "model": "super_archives.message",
	140	+ "pk": 2
	141	+ },
	142	+ {
	143	+ "fields": {
	144	+ "body": "Mensagem da lista privada nada",
	145	+ "received_time": "2015-02-24T14:15:39Z",
	146	+ "from_address": 1,
	147	+ "thread": 3,
	148	+ "spam": false,
	149	+ "subject_clean": "(no subject)",
	150	+ "message_id": "<20150224141545.1AECA19A5A0@localhost.localdomain>",
	151	+ "subject": "[PrivateList] (no subject)"
	152	+ },
	153	+ "model": "super_archives.message",
	154	+ "pk": 3
	155	+ },
	156	+ {
	157	+ "fields": {
	158	+ "text": "lista Mailman email\n",
	159	+ "message": 1,
	160	+ "is_reply": false,
	161	+ "order": 0
	162	+ },
	163	+ "model": "super_archives.messageblock",
	164	+ "pk": 1
	165	+ },
	166	+ {
	167	+ "fields": {
	168	+ "text": "nada\n",
	169	+ "message": 2,
	170	+ "is_reply": false,
	171	+ "order": 0
	172	+ },
	173	+ "model": "super_archives.messageblock",
	174	+ "pk": 2
	175	+ },
	176	+ {
	177	+ "fields": {
	178	+ "text": "Mensagem da lista privada nada\n",
	179	+ "message": 3,
	180	+ "is_reply": false,
	181	+ "order": 0
	182	+ },
	183	+ "model": "super_archives.messageblock",
	184	+ "pk": 3
	185	+ }
	186	+]
	@@ -295,3 +295,7 @@ class Command(BaseCommand, object):		@@ -295,3 +295,7 @@ class Command(BaseCommand, object):
295	raise	295	raise
296	finally:	296	finally:
297	os.remove(self.lock_file)	297	os.remove(self.lock_file)
		298	+
		299	+ for mlist in MailingList.objects.all():
		300	+ mlist.update_privacy()
		301	+ mlist.save()
	@@ -79,7 +79,7 @@ class Message(mailbox.mboxMessage):		@@ -79,7 +79,7 @@ class Message(mailbox.mboxMessage):
79	return body.strip()	79	return body.strip()
80		80
81	def get_received_datetime(self):	81	def get_received_datetime(self):
82	- if self not in ('Received'):	82	+ if 'Received' not in self:
83	return None	83	return None
84	# The time received should always be the last element	84	# The time received should always be the last element
85	# in the `Received` attribute from the message headers	85	# in the `Received` attribute from the message headers
@@ -0,0 +1,20 @@		@@ -0,0 +1,20 @@
	1	+# -- coding: utf-8 --
	2	+from __future__ import unicode_literals
	3	+
	4	+from django.db import models, migrations
	5	+
	6	+
	7	+class Migration(migrations.Migration):
	8	+
	9	+ dependencies = [
	10	+ ('super_archives', '0001_initial'),
	11	+ ]
	12	+
	13	+ operations = [
	14	+ migrations.AddField(
	15	+ model_name='mailinglist',
	16	+ name='is_private',
	17	+ field=models.BooleanField(default=False),
	18	+ preserve_default=True,
	19	+ ),
	20	+ ]
@@ -0,0 +1,66 @@		@@ -0,0 +1,66 @@
	1	+# -- coding:utf-8 --
	2	+import mock
	3	+
	4	+from colab.accounts.utils import mailman
	5	+from django.test import TestCase, Client
	6	+
	7	+
	8	+class ArchivesViewTest(TestCase):
	9	+
	10	+ fixtures = ['mailinglistdata.json']
	11	+
	12	+ def setUp(self):
	13	+ self.client = Client()
	14	+
	15	+ def authenticate_user(self):
	16	+ self.client.login(username='gustmax', password='1234')
	17	+
	18	+ def test_see_only_private_list_if_member(self):
	19	+ mailman.get_user_mailinglists = mock.Mock(
	20	+ return_value="['privatelist']")
	21	+
	22	+ self.authenticate_user()
	23	+ request = self.client.get('/archives/thread/')
	24	+
	25	+ list_data = request.context['lists']
	26	+
	27	+ self.assertEqual('lista', list_data[0][0])
	28	+ self.assertEqual('privatelist', list_data[1][0])
	29	+ self.assertEqual(2, len(list_data))
	30	+
	31	+ def test_see_only_public_if_not_logged_in(self):
	32	+ request = self.client.get('/archives/thread/')
	33	+
	34	+ list_data = request.context['lists']
	35	+
	36	+ self.assertEqual('lista', list_data[0][0])
	37	+ self.assertEqual(1, len(list_data))
	38	+
	39	+ def test_see_private_thread_in_dashboard_if_member(self):
	40	+ mailman.get_user_mailinglists = mock.Mock(
	41	+ return_value="['privatelist']")
	42	+
	43	+ self.authenticate_user()
	44	+ request = self.client.get('/dashboard')
	45	+
	46	+ latest_threads = request.context['latest_threads']
	47	+ hottest_threads = request.context['hottest_threads']
	48	+
	49	+ self.assertEqual(2, len(latest_threads))
	50	+ self.assertEqual(2, len(hottest_threads))
	51	+
	52	+ def test_dont_see_private_thread_if_logged_out(self):
	53	+ request = self.client.get('/dashboard')
	54	+
	55	+ latest_threads = request.context['latest_threads']
	56	+ hottest_threads = request.context['hottest_threads']
	57	+
	58	+ self.assertEqual(1, len(latest_threads))
	59	+ self.assertEqual(1, len(hottest_threads))
	60	+
	61	+ def test_dont_see_private_threads_in_profile_if_logged_out(self):
	62	+ request = self.client.get('/account/gustmax')
	63	+
	64	+ emails = request.context['emails']
	65	+
	66	+ self.assertEqual(1, len(emails))