Sith/com/views.py

884 lines
29 KiB
Python
Raw Permalink Normal View History

# -*- coding:utf-8 -*
#
# Copyright 2016,2017
# - Skia <skia@libskia.so>
2017-08-19 14:13:53 +00:00
# - Sli <antoine@bartuccio.fr>
#
# Ce fichier fait partie du site de l'Association des Étudiants de l'UTBM,
# http://ae.utbm.fr.
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License a published by the Free Software
# Foundation; either version 3 of the License, or (at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Sofware Foundation, Inc., 59 Temple
# Place - Suite 330, Boston, MA 02111-1307, USA.
#
#
2017-06-12 06:59:03 +00:00
from django.shortcuts import redirect, get_object_or_404
2017-01-11 11:18:42 +00:00
from django.http import HttpResponseRedirect
2017-08-21 17:53:17 +00:00
from django.views.generic import ListView, DetailView, View
2017-01-07 14:08:23 +00:00
from django.views.generic.edit import UpdateView, CreateView, DeleteView
2016-12-23 17:40:12 +00:00
from django.views.generic.detail import SingleObjectMixin
from django.utils.translation import gettext_lazy as _
from django.urls import reverse, reverse_lazy
from django.core.exceptions import ValidationError
from django.utils import timezone
2016-12-23 19:11:27 +00:00
from django.conf import settings
2017-01-07 14:08:23 +00:00
from django.db.models import Max
2017-03-12 17:13:04 +00:00
from django.forms.models import modelform_factory
2017-08-19 14:13:53 +00:00
from django.core.exceptions import PermissionDenied
from django import forms
from datetime import timedelta
from smtplib import SMTPRecipientsRefused
from com.models import Sith, News, NewsDate, Weekmail, WeekmailArticle, Screen, Poster
2018-10-04 19:29:19 +00:00
from core.views import (
CanViewMixin,
CanEditMixin,
CanEditPropMixin,
TabedViewMixin,
CanCreateMixin,
QuickNotifMixin,
)
2018-12-20 14:06:20 +00:00
from core.views.forms import SelectDateTime, MarkdownInput
from core.models import Notification, RealGroup, User
2017-08-19 14:13:53 +00:00
from club.models import Club, Mailing
from core.views.forms import TzAwareDateTimeField
# Sith object
sith = Sith.objects.first
2017-06-12 06:59:03 +00:00
2017-11-28 13:43:05 +00:00
class PosterForm(forms.ModelForm):
class Meta:
model = Poster
2018-10-04 19:29:19 +00:00
fields = [
"name",
"file",
"club",
"screens",
"date_begin",
"date_end",
"display_time",
]
widgets = {"screens": forms.CheckboxSelectMultiple}
help_texts = {"file": _("Format: 16:9 | Resolution: 1920x1080")}
2018-10-04 19:29:19 +00:00
date_begin = TzAwareDateTimeField(
2018-10-04 19:29:19 +00:00
label=_("Start date"),
required=True,
initial=timezone.now().strftime("%Y-%m-%d %H:%M:%S"),
)
date_end = TzAwareDateTimeField(label=_("End date"), required=False)
2017-12-22 11:53:43 +00:00
2017-11-28 13:43:05 +00:00
def __init__(self, *args, **kwargs):
2018-10-04 19:29:19 +00:00
self.user = kwargs.pop("user", None)
2017-11-28 13:43:05 +00:00
super(PosterForm, self).__init__(*args, **kwargs)
2017-12-05 14:24:46 +00:00
if self.user:
if not self.user.is_com_admin:
2018-10-04 19:29:19 +00:00
self.fields["club"].queryset = Club.objects.filter(
id__in=self.user.clubs_with_rights
)
self.fields.pop("display_time")
2017-11-28 13:43:05 +00:00
class ComTabsMixin(TabedViewMixin):
def get_tabs_title(self):
return _("Communication administration")
def get_list_of_tabs(self):
tab_list = []
2018-10-04 19:29:19 +00:00
tab_list.append(
{"url": reverse("com:weekmail"), "slug": "weekmail", "name": _("Weekmail")}
)
tab_list.append(
{
"url": reverse("com:weekmail_destinations"),
"slug": "weekmail_destinations",
"name": _("Weekmail destinations"),
}
)
tab_list.append(
{"url": reverse("com:info_edit"), "slug": "info", "name": _("Info message")}
)
tab_list.append(
{
"url": reverse("com:alert_edit"),
"slug": "alert",
"name": _("Alert message"),
}
)
tab_list.append(
{
"url": reverse("com:mailing_admin"),
"slug": "mailings",
"name": _("Mailing lists administration"),
}
)
tab_list.append(
{
"url": reverse("com:poster_list"),
"slug": "posters",
"name": _("Posters list"),
}
)
tab_list.append(
{
"url": reverse("com:screen_list"),
"slug": "screens",
"name": _("Screens list"),
}
)
return tab_list
2017-06-12 06:59:03 +00:00
class IsComAdminMixin(View):
def dispatch(self, request, *args, **kwargs):
2023-05-10 09:56:33 +00:00
if not request.user.is_com_admin:
raise PermissionDenied
return super(IsComAdminMixin, self).dispatch(request, *args, **kwargs)
class ComEditView(ComTabsMixin, CanEditPropMixin, UpdateView):
model = Sith
2018-10-04 19:29:19 +00:00
template_name = "core/edit.jinja"
def get_object(self, queryset=None):
return Sith.objects.first()
2017-06-12 06:59:03 +00:00
class AlertMsgEditView(ComEditView):
form_class = modelform_factory(
Sith, fields=["alert_msg"], widgets={"alert_msg": MarkdownInput}
)
current_tab = "alert"
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:alert_edit")
2017-06-12 06:59:03 +00:00
class InfoMsgEditView(ComEditView):
form_class = modelform_factory(
Sith, fields=["info_msg"], widgets={"info_msg": MarkdownInput}
)
current_tab = "info"
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:info_edit")
2017-06-12 06:59:03 +00:00
2017-01-11 00:34:16 +00:00
class WeekmailDestinationEditView(ComEditView):
2018-10-04 19:29:19 +00:00
fields = ["weekmail_destinations"]
2017-01-11 00:34:16 +00:00
current_tab = "weekmail_destinations"
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:weekmail_destinations")
2017-01-11 00:34:16 +00:00
# News
2017-06-12 06:59:03 +00:00
class NewsForm(forms.ModelForm):
class Meta:
model = News
2018-10-04 19:29:19 +00:00
fields = ["type", "title", "club", "summary", "content", "author"]
2018-12-20 14:09:44 +00:00
widgets = {
"author": forms.HiddenInput,
"type": forms.RadioSelect,
"summary": MarkdownInput,
"content": MarkdownInput,
}
2018-10-04 19:29:19 +00:00
start_date = TzAwareDateTimeField(label=_("Start date"), required=False)
end_date = TzAwareDateTimeField(label=_("End date"), required=False)
until = TzAwareDateTimeField(label=_("Until"), required=False)
2016-12-23 17:40:12 +00:00
automoderation = forms.BooleanField(label=_("Automoderation"), required=False)
def clean(self):
self.cleaned_data = super(NewsForm, self).clean()
2018-10-04 19:29:19 +00:00
if self.cleaned_data["type"] != "NOTICE":
if not self.cleaned_data["start_date"]:
self.add_error(
"start_date", ValidationError(_("This field is required."))
)
if not self.cleaned_data["end_date"]:
self.add_error(
"end_date", ValidationError(_("This field is required."))
)
2019-10-17 08:25:29 +00:00
if (
not self.has_error("start_date")
and not self.has_error("end_date")
and self.cleaned_data["start_date"] > self.cleaned_data["end_date"]
):
2018-10-04 19:29:19 +00:00
self.add_error(
"end_date",
ValidationError(
_("You crazy? You can not finish an event before starting it.")
),
)
if self.cleaned_data["type"] == "WEEKLY" and not self.cleaned_data["until"]:
self.add_error("until", ValidationError(_("This field is required.")))
return self.cleaned_data
def save(self):
ret = super(NewsForm, self).save()
self.instance.dates.all().delete()
if self.instance.type == "EVENT" or self.instance.type == "CALL":
2018-10-04 19:29:19 +00:00
NewsDate(
start_date=self.cleaned_data["start_date"],
end_date=self.cleaned_data["end_date"],
news=self.instance,
).save()
elif self.instance.type == "WEEKLY":
2018-10-04 19:29:19 +00:00
start_date = self.cleaned_data["start_date"]
end_date = self.cleaned_data["end_date"]
while start_date <= self.cleaned_data["until"]:
NewsDate(
start_date=start_date, end_date=end_date, news=self.instance
).save()
start_date += timedelta(days=7)
end_date += timedelta(days=7)
return ret
2017-06-12 06:59:03 +00:00
2016-12-23 17:40:12 +00:00
class NewsEditView(CanEditMixin, UpdateView):
model = News
form_class = NewsForm
2018-10-04 19:29:19 +00:00
template_name = "com/news_edit.jinja"
pk_url_kwarg = "news_id"
def get_initial(self):
init = {}
try:
2018-10-04 19:29:19 +00:00
init["start_date"] = (
self.object.dates.order_by("id")
.first()
.start_date.strftime("%Y-%m-%d %H:%M:%S")
)
2017-06-12 06:59:03 +00:00
except:
pass
try:
2018-10-04 19:29:19 +00:00
init["end_date"] = (
self.object.dates.order_by("id")
.first()
.end_date.strftime("%Y-%m-%d %H:%M:%S")
)
2017-06-12 06:59:03 +00:00
except:
pass
return init
2016-12-23 18:43:59 +00:00
def post(self, request, *args, **kwargs):
form = self.get_form()
2018-10-04 19:29:19 +00:00
if form.is_valid() and "preview" not in request.POST.keys():
2016-12-23 18:43:59 +00:00
return self.form_valid(form)
else:
return self.form_invalid(form)
2016-12-23 17:40:12 +00:00
def form_valid(self, form):
self.object = form.save()
2023-05-10 09:56:33 +00:00
if form.cleaned_data["automoderation"] and self.request.user.is_com_admin:
2016-12-23 17:40:12 +00:00
self.object.moderator = self.request.user
self.object.is_moderated = True
self.object.save()
else:
self.object.is_moderated = False
self.object.save()
2018-10-04 19:29:19 +00:00
for u in (
RealGroup.objects.filter(id=settings.SITH_GROUP_COM_ADMIN_ID)
.first()
.users.all()
):
if not u.notifications.filter(
type="NEWS_MODERATION", viewed=False
).exists():
Notification(
user=u,
url=reverse(
"com:news_detail", kwargs={"news_id": self.object.id}
),
type="NEWS_MODERATION",
).save()
2016-12-23 17:40:12 +00:00
return super(NewsEditView, self).form_valid(form)
2017-06-12 06:59:03 +00:00
2017-05-13 16:31:23 +00:00
class NewsCreateView(CanCreateMixin, CreateView):
model = News
form_class = NewsForm
2018-10-04 19:29:19 +00:00
template_name = "com/news_edit.jinja"
def get_initial(self):
2018-10-04 19:29:19 +00:00
init = {"author": self.request.user}
try:
2018-10-04 19:29:19 +00:00
init["club"] = Club.objects.filter(id=self.request.GET["club"]).first()
2017-06-12 06:59:03 +00:00
except:
pass
return init
2016-12-23 18:43:59 +00:00
def post(self, request, *args, **kwargs):
form = self.get_form()
2018-10-04 19:29:19 +00:00
if form.is_valid() and "preview" not in request.POST.keys():
2016-12-23 18:43:59 +00:00
return self.form_valid(form)
else:
self.object = form.instance
return self.form_invalid(form)
2016-12-23 17:40:12 +00:00
def form_valid(self, form):
self.object = form.save()
2023-05-10 09:56:33 +00:00
if form.cleaned_data["automoderation"] and self.request.user.is_com_admin:
2016-12-23 17:40:12 +00:00
self.object.moderator = self.request.user
self.object.is_moderated = True
self.object.save()
2016-12-23 19:11:27 +00:00
else:
2018-10-04 19:29:19 +00:00
for u in (
RealGroup.objects.filter(id=settings.SITH_GROUP_COM_ADMIN_ID)
.first()
.users.all()
):
if not u.notifications.filter(
type="NEWS_MODERATION", viewed=False
).exists():
Notification(
user=u,
url=reverse("com:news_admin_list"),
type="NEWS_MODERATION",
).save()
2016-12-23 17:40:12 +00:00
return super(NewsCreateView, self).form_valid(form)
2017-06-12 06:59:03 +00:00
class NewsDeleteView(CanEditMixin, DeleteView):
model = News
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "news_id"
template_name = "core/delete_confirm.jinja"
success_url = reverse_lazy("com:news_admin_list")
2017-09-17 17:33:53 +00:00
2016-12-23 17:40:12 +00:00
class NewsModerateView(CanEditMixin, SingleObjectMixin):
model = News
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "news_id"
2016-12-23 17:40:12 +00:00
def get(self, request, *args, **kwargs):
self.object = self.get_object()
2018-10-04 19:29:19 +00:00
if "remove" in request.GET.keys():
2017-05-13 16:31:23 +00:00
self.object.is_moderated = False
else:
self.object.is_moderated = True
2016-12-23 17:40:12 +00:00
self.object.moderator = request.user
self.object.save()
2018-10-04 19:29:19 +00:00
if "next" in self.request.GET.keys():
return redirect(self.request.GET["next"])
return redirect("com:news_admin_list")
2016-12-23 17:40:12 +00:00
2017-06-12 06:59:03 +00:00
2016-12-23 17:40:12 +00:00
class NewsAdminListView(CanEditMixin, ListView):
model = News
2018-10-04 19:29:19 +00:00
template_name = "com/news_admin_list.jinja"
queryset = News.objects.all()
2017-06-12 06:59:03 +00:00
2016-12-23 17:40:12 +00:00
class NewsListView(CanViewMixin, ListView):
model = News
2018-10-04 19:29:19 +00:00
template_name = "com/news_list.jinja"
queryset = News.objects.filter(is_moderated=True)
2016-12-23 17:40:12 +00:00
def get_context_data(self, **kwargs):
kwargs = super(NewsListView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["NewsDate"] = NewsDate
kwargs["timedelta"] = timedelta
kwargs["birthdays"] = (
User.objects.filter(
date_of_birth__month=timezone.now().month,
date_of_birth__day=timezone.now().day,
)
.filter(role__in=["STUDENT", "FORMER STUDENT"])
.order_by("-date_of_birth")
)
2016-12-23 17:40:12 +00:00
return kwargs
2017-06-12 06:59:03 +00:00
2016-12-23 17:40:12 +00:00
class NewsDetailView(CanViewMixin, DetailView):
model = News
2018-10-04 19:29:19 +00:00
template_name = "com/news_detail.jinja"
pk_url_kwarg = "news_id"
2016-12-23 17:40:12 +00:00
2017-01-02 23:07:45 +00:00
# Weekmail
2017-06-12 06:59:03 +00:00
class WeekmailPreviewView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, DetailView):
2017-01-10 17:30:27 +00:00
model = Weekmail
2018-10-04 19:29:19 +00:00
template_name = "com/weekmail_preview.jinja"
success_url = reverse_lazy("com:weekmail")
2017-01-11 11:18:42 +00:00
current_tab = "weekmail"
def dispatch(self, request, *args, **kwargs):
self.bad_recipients = []
return super(WeekmailPreviewView, self).dispatch(request, *args, **kwargs)
2017-01-11 11:18:42 +00:00
def post(self, request, *args, **kwargs):
self.object = self.get_object()
if request.POST["send"] == "validate":
try:
2017-01-11 11:18:42 +00:00
self.object.send()
2018-10-04 19:29:19 +00:00
return HttpResponseRedirect(
reverse("com:weekmail") + "?qn_weekmail_send_success"
)
except SMTPRecipientsRefused as e:
self.bad_recipients = e.recipients
elif request.POST["send"] == "clean":
try:
self.object.send() # This should fail
except SMTPRecipientsRefused as e:
users = User.objects.filter(email__in=e.recipients.keys())
for u in users:
u.preferences.receive_weekmail = False
u.preferences.save()
self.quick_notif_list += ["qn_success"]
return super(WeekmailPreviewView, self).get(request, *args, **kwargs)
2017-01-10 17:30:27 +00:00
def get_object(self, queryset=None):
2018-10-04 19:29:19 +00:00
return self.model.objects.filter(sent=False).order_by("-id").first()
2017-01-10 17:30:27 +00:00
def get_context_data(self, **kwargs):
"""Add rendered weekmail"""
kwargs = super(WeekmailPreviewView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["weekmail_rendered"] = self.object.render_html()
kwargs["bad_recipients"] = self.bad_recipients
2017-01-10 17:30:27 +00:00
return kwargs
2017-06-12 06:59:03 +00:00
2017-01-15 22:09:30 +00:00
class WeekmailEditView(ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView):
2017-01-02 23:07:45 +00:00
model = Weekmail
2018-10-04 19:29:19 +00:00
template_name = "com/weekmail.jinja"
form_class = modelform_factory(
Weekmail,
fields=["title", "intro", "joke", "protip", "conclusion"],
help_texts={"title": _("Delete and save to regenerate")},
2018-12-20 14:06:20 +00:00
widgets={
"intro": MarkdownInput,
"joke": MarkdownInput,
"protip": MarkdownInput,
"conclusion": MarkdownInput,
},
2018-10-04 19:29:19 +00:00
)
success_url = reverse_lazy("com:weekmail")
2017-01-11 00:34:16 +00:00
current_tab = "weekmail"
2017-01-02 23:07:45 +00:00
def get_object(self, queryset=None):
2018-10-04 19:29:19 +00:00
weekmail = self.model.objects.filter(sent=False).order_by("-id").first()
2017-01-03 15:50:53 +00:00
if not weekmail.title:
now = timezone.now()
2018-10-04 19:29:19 +00:00
weekmail.title = _("Weekmail of the ") + (
now + timedelta(days=6 - now.weekday())
).strftime("%d/%m/%Y")
2017-01-10 17:30:27 +00:00
weekmail.save()
2017-01-03 15:50:53 +00:00
return weekmail
2017-01-02 23:07:45 +00:00
2017-01-07 14:08:23 +00:00
def get(self, request, *args, **kwargs):
self.object = self.get_object()
2018-10-04 19:29:19 +00:00
if "up_article" in request.GET.keys():
art = get_object_or_404(
WeekmailArticle, id=request.GET["up_article"], weekmail=self.object
)
prev_art = (
self.object.articles.order_by("rank").filter(rank__lt=art.rank).last()
)
2017-01-07 14:08:23 +00:00
if prev_art:
art.rank, prev_art.rank = prev_art.rank, art.rank
art.save()
prev_art.save()
2018-10-04 19:29:19 +00:00
self.quick_notif_list += ["qn_success"]
if "down_article" in request.GET.keys():
art = get_object_or_404(
WeekmailArticle, id=request.GET["down_article"], weekmail=self.object
)
next_art = (
self.object.articles.order_by("rank").filter(rank__gt=art.rank).first()
)
2017-01-07 14:08:23 +00:00
if next_art:
art.rank, next_art.rank = next_art.rank, art.rank
art.save()
next_art.save()
2018-10-04 19:29:19 +00:00
self.quick_notif_list += ["qn_success"]
if "add_article" in request.GET.keys():
art = get_object_or_404(
WeekmailArticle, id=request.GET["add_article"], weekmail=None
)
2017-01-07 14:08:23 +00:00
art.weekmail = self.object
2018-10-04 19:29:19 +00:00
art.rank = self.object.articles.aggregate(Max("rank"))["rank__max"] or 0
2017-01-07 14:08:23 +00:00
art.rank += 1
art.save()
2018-10-04 19:29:19 +00:00
self.quick_notif_list += ["qn_success"]
if "del_article" in request.GET.keys():
art = get_object_or_404(
WeekmailArticle, id=request.GET["del_article"], weekmail=self.object
)
2017-01-07 14:08:23 +00:00
art.weekmail = None
art.rank = -1
art.save()
2018-10-04 19:29:19 +00:00
self.quick_notif_list += ["qn_success"]
2017-01-07 14:08:23 +00:00
return super(WeekmailEditView, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
2021-09-26 02:20:49 +00:00
"""Add orphan articles"""
2017-01-07 14:08:23 +00:00
kwargs = super(WeekmailEditView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["orphans"] = WeekmailArticle.objects.filter(weekmail=None)
2017-01-07 14:08:23 +00:00
return kwargs
2017-06-12 06:59:03 +00:00
2018-10-04 19:29:19 +00:00
class WeekmailArticleEditView(
ComTabsMixin, QuickNotifMixin, CanEditPropMixin, UpdateView
):
2017-01-07 14:08:23 +00:00
"""Edit an article"""
2018-10-04 19:29:19 +00:00
2017-01-07 14:08:23 +00:00
model = WeekmailArticle
2018-12-20 14:06:20 +00:00
form_class = modelform_factory(
WeekmailArticle,
fields=["title", "club", "content"],
widgets={"content": MarkdownInput},
)
2017-01-07 14:08:23 +00:00
pk_url_kwarg = "article_id"
2018-10-04 19:29:19 +00:00
template_name = "core/edit.jinja"
success_url = reverse_lazy("com:weekmail")
2017-01-07 14:08:23 +00:00
quick_notif_url_arg = "qn_weekmail_article_edit"
2017-01-11 00:34:16 +00:00
current_tab = "weekmail"
2017-01-07 14:08:23 +00:00
2017-06-12 06:59:03 +00:00
class WeekmailArticleCreateView(QuickNotifMixin, CreateView):
2017-01-07 14:08:23 +00:00
"""Post an article"""
2018-10-04 19:29:19 +00:00
2017-01-07 14:08:23 +00:00
model = WeekmailArticle
2018-12-20 14:06:20 +00:00
form_class = modelform_factory(
WeekmailArticle,
fields=["title", "club", "content"],
widgets={"content": MarkdownInput},
)
2018-10-04 19:29:19 +00:00
template_name = "core/create.jinja"
success_url = reverse_lazy("core:user_tools")
2017-01-07 14:08:23 +00:00
quick_notif_url_arg = "qn_weekmail_new_article"
def get_initial(self):
init = {}
try:
2018-10-04 19:29:19 +00:00
init["club"] = Club.objects.filter(id=self.request.GET["club"]).first()
2017-06-12 06:59:03 +00:00
except:
pass
return init
def post(self, request, *args, **kwargs):
form = self.get_form()
self.object = form.instance
2017-06-12 06:59:03 +00:00
form.is_valid() #  Valid a first time to populate club field
try:
m = form.instance.club.get_membership_for(request.user)
if m.role <= settings.SITH_MAXIMUM_FREE_ROLE:
raise
except:
2018-10-04 19:29:19 +00:00
form.add_error(
"club",
ValidationError(
_(
"You must be a board member of the selected club to post in the Weekmail."
)
),
)
if form.is_valid() and not "preview" in request.POST.keys():
return self.form_valid(form)
else:
return self.form_invalid(form)
2017-01-07 14:08:23 +00:00
def form_valid(self, form):
form.instance.author = self.request.user
return super(WeekmailArticleCreateView, self).form_valid(form)
2017-06-12 06:59:03 +00:00
2017-01-15 22:09:30 +00:00
class WeekmailArticleDeleteView(CanEditPropMixin, DeleteView):
2017-01-07 14:08:23 +00:00
"""Delete an article"""
2018-10-04 19:29:19 +00:00
2017-01-07 14:08:23 +00:00
model = WeekmailArticle
2018-10-04 19:29:19 +00:00
template_name = "core/delete_confirm.jinja"
success_url = reverse_lazy("com:weekmail")
pk_url_kwarg = "article_id"
2017-08-19 14:13:53 +00:00
class MailingListAdminView(ComTabsMixin, ListView):
template_name = "com/mailing_admin.jinja"
model = Mailing
current_tab = "mailings"
def dispatch(self, request, *args, **kwargs):
2023-05-10 09:56:33 +00:00
if not (request.user.is_com_admin or request.user.is_root):
2017-08-19 14:13:53 +00:00
raise PermissionDenied
return super(MailingListAdminView, self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
kwargs = super(MailingListAdminView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["moderated"] = self.get_queryset().filter(is_moderated=True).all()
kwargs["unmoderated"] = self.get_queryset().filter(is_moderated=False).all()
kwargs["has_moderated"] = len(kwargs["moderated"]) > 0
kwargs["has_unmoderated"] = len(kwargs["unmoderated"]) > 0
2017-08-19 14:13:53 +00:00
return kwargs
2017-08-21 17:53:17 +00:00
class MailingModerateView(View):
def get(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
mailing = get_object_or_404(Mailing, pk=kwargs["mailing_id"])
2017-08-21 17:53:17 +00:00
if mailing.can_moderate(request.user):
mailing.is_moderated = True
mailing.moderator = request.user
mailing.save()
2018-10-04 19:29:19 +00:00
return redirect("com:mailing_admin")
2017-08-21 17:53:17 +00:00
raise PermissionDenied
2017-11-28 13:43:05 +00:00
class PosterListBaseView(ListView):
"""List communication posters"""
2018-10-04 19:29:19 +00:00
current_tab = "posters"
model = Poster
2018-10-04 19:29:19 +00:00
template_name = "com/poster_list.jinja"
2017-11-28 13:43:05 +00:00
def dispatch(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
club_id = kwargs.pop("club_id", None)
2017-12-05 14:53:36 +00:00
self.club = None
2017-12-05 14:24:46 +00:00
if club_id:
self.club = get_object_or_404(Club, pk=club_id)
2017-11-28 13:43:05 +00:00
return super(PosterListBaseView, self).dispatch(request, *args, **kwargs)
def get_queryset(self):
2017-12-05 14:24:46 +00:00
if self.request.user.is_com_admin:
2018-10-04 19:29:19 +00:00
return Poster.objects.all().order_by("-date_begin")
2017-12-05 14:24:46 +00:00
else:
return Poster.objects.filter(club=self.club.id)
def get_context_data(self, **kwargs):
2017-11-28 13:43:05 +00:00
kwargs = super(PosterListBaseView, self).get_context_data(**kwargs)
2017-12-05 14:24:46 +00:00
if not self.request.user.is_com_admin:
2018-10-04 19:29:19 +00:00
kwargs["club"] = self.club
return kwargs
2017-11-28 13:43:05 +00:00
class PosterCreateBaseView(CreateView):
"""Create communication poster"""
2018-10-04 19:29:19 +00:00
current_tab = "posters"
2017-11-01 17:12:33 +00:00
form_class = PosterForm
2018-10-04 19:29:19 +00:00
template_name = "core/create.jinja"
2017-11-28 13:43:05 +00:00
def get_queryset(self):
return Poster.objects.all()
def dispatch(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
if "club_id" in kwargs:
self.club = get_object_or_404(Club, pk=kwargs["club_id"])
2017-11-28 13:43:05 +00:00
return super(PosterCreateBaseView, self).dispatch(request, *args, **kwargs)
2017-12-05 14:24:46 +00:00
def get_form_kwargs(self):
kwargs = super(PosterCreateBaseView, self).get_form_kwargs()
2018-10-04 19:29:19 +00:00
kwargs.update({"user": self.request.user})
2017-12-05 14:24:46 +00:00
return kwargs
2017-11-01 17:12:33 +00:00
def get_context_data(self, **kwargs):
2017-11-28 13:43:05 +00:00
kwargs = super(PosterCreateBaseView, self).get_context_data(**kwargs)
2017-12-05 14:24:46 +00:00
if not self.request.user.is_com_admin:
2018-10-04 19:29:19 +00:00
kwargs["club"] = self.club
2017-11-01 17:12:33 +00:00
return kwargs
2017-11-28 13:43:05 +00:00
def form_valid(self, form):
2017-12-05 14:24:46 +00:00
if self.request.user.is_com_admin:
2017-11-28 13:43:05 +00:00
form.instance.is_moderated = True
return super(PosterCreateBaseView, self).form_valid(form)
2017-11-28 13:43:05 +00:00
class PosterEditBaseView(UpdateView):
"""Edit communication poster"""
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "poster_id"
current_tab = "posters"
2017-11-01 17:12:33 +00:00
form_class = PosterForm
2018-10-04 19:29:19 +00:00
template_name = "com/poster_edit.jinja"
2017-11-28 13:43:05 +00:00
2018-04-26 12:48:29 +00:00
def get_initial(self):
init = {}
try:
2018-10-04 19:29:19 +00:00
init["date_begin"] = self.object.date_begin.strftime("%Y-%m-%d %H:%M:%S")
2018-04-26 12:48:29 +00:00
except Exception:
pass
try:
2018-10-04 19:29:19 +00:00
init["date_end"] = self.object.date_end.strftime("%Y-%m-%d %H:%M:%S")
2018-04-26 12:48:29 +00:00
except Exception:
pass
return init
2017-11-28 13:43:05 +00:00
def dispatch(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
if "club_id" in kwargs and kwargs["club_id"]:
2017-11-28 13:43:05 +00:00
try:
2018-10-04 19:29:19 +00:00
self.club = Club.objects.get(pk=kwargs["club_id"])
2017-11-28 13:43:05 +00:00
except Club.DoesNotExist:
2017-12-05 14:24:46 +00:00
raise PermissionDenied
2017-11-28 13:43:05 +00:00
return super(PosterEditBaseView, self).dispatch(request, *args, **kwargs)
def get_queryset(self):
return Poster.objects.all()
2017-12-05 14:24:46 +00:00
def get_form_kwargs(self):
kwargs = super(PosterEditBaseView, self).get_form_kwargs()
2018-10-04 19:29:19 +00:00
kwargs.update({"user": self.request.user})
2017-12-05 14:24:46 +00:00
return kwargs
2017-11-28 13:43:05 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterEditBaseView, self).get_context_data(**kwargs)
if hasattr(self, "club"):
kwargs["club"] = self.club
2017-11-28 13:43:05 +00:00
return kwargs
def form_valid(self, form):
if self.request.user.is_com_admin:
2017-11-28 13:43:05 +00:00
form.instance.is_moderated = False
return super(PosterEditBaseView, self).form_valid(form)
2017-12-05 14:24:46 +00:00
class PosterDeleteBaseView(DeleteView):
"""Edit communication poster"""
2018-10-04 19:29:19 +00:00
2017-12-05 14:24:46 +00:00
pk_url_kwarg = "poster_id"
2017-11-28 13:43:05 +00:00
current_tab = "posters"
model = Poster
2018-10-04 19:29:19 +00:00
template_name = "core/delete_confirm.jinja"
2017-12-05 14:24:46 +00:00
def dispatch(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
if "club_id" in kwargs and kwargs["club_id"]:
2017-12-05 14:24:46 +00:00
try:
2018-10-04 19:29:19 +00:00
self.club = Club.objects.get(pk=kwargs["club_id"])
2017-12-05 14:24:46 +00:00
except Club.DoesNotExist:
raise PermissionDenied
return super(PosterDeleteBaseView, self).dispatch(request, *args, **kwargs)
class PosterListView(IsComAdminMixin, ComTabsMixin, PosterListBaseView):
"""List communication posters"""
2017-11-28 13:43:05 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterListView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["app"] = "com"
2017-11-28 13:43:05 +00:00
return kwargs
class PosterCreateView(IsComAdminMixin, ComTabsMixin, PosterCreateBaseView):
"""Create communication poster"""
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:poster_list")
2017-11-28 13:43:05 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterCreateView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["app"] = "com"
2017-11-28 13:43:05 +00:00
return kwargs
class PosterEditView(IsComAdminMixin, ComTabsMixin, PosterEditBaseView):
"""Edit communication poster"""
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:poster_list")
2017-11-01 17:12:33 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterEditView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["app"] = "com"
2017-11-01 17:12:33 +00:00
return kwargs
2017-12-05 14:24:46 +00:00
class PosterDeleteView(IsComAdminMixin, ComTabsMixin, PosterDeleteBaseView):
"""Delete communication poster"""
2018-10-04 19:29:19 +00:00
success_url = reverse_lazy("com:poster_list")
class PosterModerateListView(IsComAdminMixin, ComTabsMixin, ListView):
"""Moderate list communication poster"""
2018-10-04 19:29:19 +00:00
current_tab = "posters"
model = Poster
2018-10-04 19:29:19 +00:00
template_name = "com/poster_moderate.jinja"
2017-11-28 13:43:05 +00:00
queryset = Poster.objects.filter(is_moderated=False).all()
2017-11-01 17:12:33 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterModerateListView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["app"] = "com"
return kwargs
2017-11-01 17:12:33 +00:00
class PosterModerateView(IsComAdminMixin, ComTabsMixin, View):
"""Moderate communication poster"""
2018-10-04 19:29:19 +00:00
def get(self, request, *args, **kwargs):
2018-10-04 19:29:19 +00:00
obj = get_object_or_404(Poster, pk=kwargs["object_id"])
2017-10-23 07:30:26 +00:00
if obj.can_be_moderated_by(request.user):
obj.is_moderated = True
obj.moderator = request.user
obj.save()
2018-10-04 19:29:19 +00:00
return redirect("com:poster_moderate_list")
raise PermissionDenied
2017-11-01 17:12:33 +00:00
def get_context_data(self, **kwargs):
kwargs = super(PosterModerateListView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["app"] = "com"
2017-11-01 17:12:33 +00:00
return kwargs
class ScreenListView(IsComAdminMixin, ComTabsMixin, ListView):
"""List communication screens"""
2018-10-04 19:29:19 +00:00
current_tab = "screens"
model = Screen
2018-10-04 19:29:19 +00:00
template_name = "com/screen_list.jinja"
class ScreenSlideshowView(DetailView):
"""Slideshow of actives posters"""
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "screen_id"
model = Screen
2018-10-04 19:29:19 +00:00
template_name = "com/screen_slideshow.jinja"
def get_context_data(self, **kwargs):
kwargs = super(ScreenSlideshowView, self).get_context_data(**kwargs)
2018-10-04 19:29:19 +00:00
kwargs["posters"] = self.object.active_posters()
return kwargs
class ScreenCreateView(IsComAdminMixin, ComTabsMixin, CreateView):
"""Create communication screen"""
2018-10-04 19:29:19 +00:00
current_tab = "screens"
model = Screen
2018-10-04 19:29:19 +00:00
fields = ["name"]
template_name = "core/create.jinja"
success_url = reverse_lazy("com:screen_list")
class ScreenEditView(IsComAdminMixin, ComTabsMixin, UpdateView):
"""Edit communication screen"""
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "screen_id"
current_tab = "screens"
model = Screen
2018-10-04 19:29:19 +00:00
fields = ["name"]
template_name = "com/screen_edit.jinja"
success_url = reverse_lazy("com:screen_list")
class ScreenDeleteView(IsComAdminMixin, ComTabsMixin, DeleteView):
"""Delete communication screen"""
2018-10-04 19:29:19 +00:00
pk_url_kwarg = "screen_id"
current_tab = "screens"
model = Screen
2018-10-04 19:29:19 +00:00
template_name = "core/delete_confirm.jinja"
success_url = reverse_lazy("com:screen_list")