def on_user_subscribed(sender, **kwargs):
user_email = kwargs["user_email"]
User = get_user_model()
try:
user = User.objects.get(email=user_email)
except User.DoesNotExist:
try:
emailaddress = EmailAddress.objects.get(email=user_email)
except EmailAddress.DoesNotExist:
return # No such user
user = emailaddress.user
cache.delete("User:%s:subscriptions" % user.id, version=2)
get_subscriptions(user)
def get_sender(request, mlist):
"""Returns the appropriate sender email address"""
if not request.user.is_authenticated:
return None
# Fallback to the logged-in user
address = request.user.email
# Try to get the email used to susbscribe to the list
subscriptions = get_subscriptions(request.user)
if mlist.list_id in subscriptions:
address = subscriptions[mlist.list_id]
return str(address)
def is_mlist_authorized(request, mlist):
if not mlist.is_private:
return True
if request.user.is_superuser:
return True
if not request.user.is_authenticated:
return False
# Private list and logged-in user: check subscriptions
if mlist.list_id in get_subscriptions(request.user):
return True
else:
return False
def subscriptions(request):
profile = request.user.hyperkitty_profile
mm_user_id = get_mailman_user_id(request.user)
subs = []
for mlist_id in get_subscriptions(request.user):
try:
mlist = MailingList.objects.get(list_id=mlist_id)
except MailingList.DoesNotExist:
mlist = None # no archived email yet
posts_count = likes = dislikes = 0
first_post = all_posts_url = None
if mlist is not None:
list_name = mlist.name
posts_count = profile.emails.filter(
mailinglist__name=mlist.name).count()
likes, dislikes = profile.get_votes_in_list(mlist.name)
first_post = profile.get_first_post(mlist)
if mm_user_id is not None:
all_posts_url = "%s?list=%s" % (
reverse("hk_user_posts", args=[mm_user_id]),
mlist.name)
else:
list_name = get_mailman_client().get_list(mlist_id).fqdn_listname
likestatus = "neutral"
if likes - dislikes >= 10:
likestatus = "likealot"
elif likes - dislikes > 0:
likestatus = "like"
subs.append({
"list_name": list_name,
"mlist": mlist,
"posts_count": posts_count,
"first_post": first_post,
"likes": likes,
"dislikes": dislikes,
"likestatus": likestatus,
"all_posts_url": all_posts_url,
})
return render(request, 'hyperkitty/user_profile/subscriptions.html', {
"subscriptions": subs,
"subpage": "subscriptions",
})
def index(request):
mlists = MailingList.objects.all()
sort_mode = request.GET.get("sort", "popular")
# Domain filtering
if getattr(settings, 'FILTER_VHOST', False):
domain = request.get_host().split(":")[0]
if domain.startswith("www."):
domain = domain[4:]
domain = "@%s" % domain
mlists = mlists.filter(name__iendswith=domain)
# Name filtering
name_filter = request.GET.get('name')
if name_filter:
sort_mode = "name"
mlists = mlists.filter(
Q(name__icontains=name_filter) |
Q(display_name__icontains=name_filter)
)
if mlists.count() == 1:
return redirect(
'hk_list_overview', mlist_fqdn=mlists.first().name)
# Access Filtering
if request.user.is_superuser:
# Superusers see everything
pass
elif request.user.is_authenticated:
# For authenticated users show only their subscriptions
# and public lists
mlists = mlists.filter(
Q(list_id__in=get_subscriptions(request.user)) |
Q(archive_policy=ArchivePolicy.public.value)
)
else:
# Unauthenticated users only see public lists
mlists = mlists.filter(
archive_policy=ArchivePolicy.public.value)
# Sorting
if sort_mode == "name":
mlists = mlists.order_by("name")
elif sort_mode == "active":
mlists = list(mlists)
mlists.sort(key=lambda l: l.recent_threads_count, reverse=True)
elif sort_mode == "popular":
mlists = list(mlists)
mlists.sort(key=lambda l: l.recent_participants_count, reverse=True)
elif sort_mode == "creation":
mlists = mlists.order_by("-created_at")
else:
return HttpResponse("Wrong search parameter",
content_type="text/plain", status=500)
mlists = paginate(mlists, request.GET.get('page'),
request.GET.get('count'))
context = {
'view_name': 'all_lists',
'all_lists': mlists,
'sort_mode': sort_mode,
}
return render(request, "hyperkitty/index.html", context)
def search(request):
""" Returns messages corresponding to a query """
mlist_fqdn = request.GET.get("mlist")
if mlist_fqdn is None:
mlist = None
else:
try:
mlist = MailingList.objects.get(name=mlist_fqdn)
except MailingList.DoesNotExist:
raise Http404("No archived mailing-list by that name.")
if not is_mlist_authorized(request, mlist):
return render(request,
"hyperkitty/errors/private.html", {
"mlist": mlist,
},
status=403)
query = ''
results = EmptySearchQuerySet()
sqs = RelatedSearchQuerySet()
# Remove private non-subscribed lists
if mlist is not None:
sqs = sqs.filter(mailinglist__exact=mlist.name)
else:
excluded_mlists = MailingList.objects.filter(
archive_policy=ArchivePolicy.private.value)
if request.user.is_authenticated:
subscriptions = get_subscriptions(request.user)
excluded_mlists = excluded_mlists.exclude(
list_id__in=subscriptions.keys())
excluded_mlists = excluded_mlists.values_list("name", flat=True)
sqs = sqs.exclude(mailinglist__in=excluded_mlists)
# Sorting
sort_mode = request.GET.get('sort')
if sort_mode == "date-asc":
sqs = sqs.order_by("date")
elif sort_mode == "date-desc":
sqs = sqs.order_by("-date")
# Handle data
if request.GET.get('q'):
form = SearchForm(request.GET, searchqueryset=sqs, load_all=True)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
else:
form = SearchForm(searchqueryset=sqs, load_all=True)
try:
emails = paginate(
results,
request.GET.get('page'),
request.GET.get('count'),
)
except Exception as e:
backend = settings.HAYSTACK_CONNECTIONS[DEFAULT_ALIAS]["ENGINE"]
if backend == "haystack.backends.whoosh_backend.WhooshEngine":
from whoosh.qparser.common import QueryParserError
search_exception = QueryParserError
if backend == "xapian_backend.XapianEngine":
from xapian import QueryParserError
search_exception = QueryParserError
if not isinstance(e, search_exception):
raise
emails = paginate([])
form.add_error(
"q",
ValidationError(
_('Parsing error: %(error)s'),
params={"error": e},
code="parse",
))
for email in emails:
if request.user.is_authenticated:
email.object.myvote = email.object.votes.filter(
user=request.user).first()
else:
email.object.myvote = None
context = {
'mlist': mlist,
'form': form,
'emails': emails,
'query': query,
'sort_mode': sort_mode,
'suggestion': None,
}
if results.query.backend.include_spelling:
context['suggestion'] = form.get_suggestion()
return render(request, "hyperkitty/search_results.html", context)
def test_get_subscriptions_no_user(self):
with patch('django_mailman3.lib.mailman.get_mailman_user') as gmu:
gmu.return_value = None
self.assertEqual(mailman.get_subscriptions(self.user), {})
def test_get_subscriptions(self):
fake_member = FakeMMMember("list.example.com", "*****@*****.**")
self.mm_user.subscriptions = [fake_member]
self.assertEqual(mailman.get_subscriptions(self.user),
{"list.example.com": "*****@*****.**"})
def index(request):
mlists = MailingList.objects.all()
sort_mode = request.GET.get("sort", "popular")
# Domain filtering
if getattr(settings, 'FILTER_VHOST', False):
our_lists = MailingList.objects.none()
domain = request.get_host().split(":")[0]
mail_hosts = []
for mlist in mlists:
mail_host = re.sub('^.*@', '', mlist.name)
try:
if (MailDomain.objects.get(
mail_domain=mail_host).site.domain == domain):
if mail_host not in mail_hosts:
mail_hosts.append(mail_host)
except MailDomain.DoesNotExist:
pass
if len(mail_hosts) == 0:
mail_hosts = [domain]
for domain in mail_hosts:
domain = '@%s' % domain
our_lists = our_lists | mlists.filter(name__iendswith=domain)
mlists = our_lists
# Name filtering
name_filter = request.GET.get('name')
if name_filter:
sort_mode = "name"
mlists = mlists.filter(
Q(name__icontains=name_filter)
| Q(display_name__icontains=name_filter))
if mlists.count() == 1:
return redirect('hk_list_overview', mlist_fqdn=mlists.first().name)
# Access Filtering
if request.user.is_superuser:
# Superusers see everything
pass
elif request.user.is_authenticated:
# For authenticated users show only their subscriptions
# and public lists
mlists = mlists.filter(
Q(list_id__in=get_subscriptions(request.user))
| Q(archive_policy=ArchivePolicy.public.value))
else:
# Unauthenticated users only see public lists
mlists = mlists.filter(archive_policy=ArchivePolicy.public.value)
# Sorting
if sort_mode == "name":
mlists = mlists.order_by("name")
elif sort_mode == "active":
mlists = list(mlists)
mlists.sort(key=lambda l: l.recent_threads_count, reverse=True)
elif sort_mode == "popular":
mlists = list(mlists)
mlists.sort(key=lambda l: l.recent_participants_count, reverse=True)
elif sort_mode == "creation":
mlists = mlists.order_by("-created_at")
else:
return HttpResponse("Wrong search parameter",
content_type="text/plain",
status=500)
# Inactive List Setting
show_inactive = getattr(settings, 'SHOW_INACTIVE_LISTS_DEFAULT', False)
mlists = paginate(mlists, request.GET.get('page'),
request.GET.get('count'))
context = {
'view_name': 'all_lists',
'all_lists': mlists,
'sort_mode': sort_mode,
'show_inactive': show_inactive
}
return render(request, "hyperkitty/index.html", context)
