Dataset Viewer
Instruction
stringlengths 13
145k
| input_code
stringlengths 35
390k
| output_code
stringlengths 35
390k
|
|---|---|---|
Separer les differentes actions d'edition d'un groupe en plusieurs pages
Il faudrait diviser les actions des pages d'edition en plusieurs sous pages
- [ ] Convertir les pages pour utiliser le template update base
- [ ] Mettre les membres dans une nouvelle page
|
server/apps/group/urls.py
<|code_start|>from django.conf.urls import url
from django.urls import path
from .views import *
app_name = 'group'
urlpatterns = [
path('<slug:pk>/', DetailClubView.as_view(), name='detail'),
path('<slug:pk>/edit', UpdateClubView.as_view(), name='update'),
path('<slug:group_slug>/member/add/<slug:user_id>', add_member, name='add-member'),
path('<slug:pk>/members/edit', edit_named_memberships, name='editNamedMemberships'),
path('', ListClubView.as_view(), name='list'),
path('<slug:group_slug>/events/edit', UpdateClubEventsView.as_view(), name='update-events')
]<|code_end|>
server/apps/group/views.py
<|code_start|>from django.shortcuts import redirect, render
from django.views.generic import DetailView, UpdateView, ListView, View
from .models import Club, Group, NamedMembership
from .forms import NamedMembershipClubFormset
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.contrib.auth.mixins import UserPassesTestMixin
from apps.student.models import Student
from apps.event.models import Event
from apps.event.forms import EventGroupFormSet
class ListClubView(ListView):
model = Club
template_name = 'group/club_list.html'
class UpdateClubView(UpdateView):
model = Club
template_name = 'group/club_update.html'
fields = ['description', 'admins', 'logo']
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
memberships = NamedMembership.objects.filter(group=self.object)
membersForm = NamedMembershipClubFormset(queryset=memberships)
context['members'] = membersForm
return context
class UpdateClubEventsView(UserPassesTestMixin, View):
template_name = 'group/club_events_update.html'
def test_func(self):
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = Event.objects.filter(group=kwargs['group_slug'])
context['form'] = EventGroupFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
def delete(self, request, group_slug, event_id):
print('Hello')
event = Event.objects.delete(group=group_slug, id=event_id)
return redirect('group:update-events')
class DetailClubView(DetailView):
model = Club
template_name = 'group/club_detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
members = NamedMembership.objects.filter(group=self.object)
context['members'] = members
return context
@login_required
def add_member(request, group_slug, student_id):
"""Add a user to a club"""
group = Group.get_group_by_slug(group_slug)
student = Student.objects.get(id=student_id)
if isinstance(Club, group):
NamedMembership.objects.create(student=student, group=group)
@require_http_methods(['POST'])
@login_required
def edit_named_memberships(request, pk):
club = Club.objects.get(pk=pk)
form = NamedMembershipClubFormset(request.POST)
if form.is_valid():
members = form.save(commit=False)
for member in members:
member.group = club
member.save()
for member in form.deleted_objects:
member.delete()
messages.success(request, 'Membres modifies')
return redirect('group:update', pk)
else:
messages.warning(request, form.errors)
return redirect('group:update', pk)
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventGroupFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
server/apps/group/urls.py
<|code_start|>from django.conf.urls import url
from django.urls import path
from .views import *
app_name = 'group'
urlpatterns = [
path('<slug:pk>/', DetailClubView.as_view(), name='detail'),
path('<slug:pk>/edit', UpdateClubView.as_view(), name='update'),
path('<slug:group_slug>/member/add/<slug:user_id>', add_member, name='add-member'),
path('', ListClubView.as_view(), name='list'),
path('<slug:group_slug>/events/edit', UpdateGroupEventsView.as_view(), name='update-events'),
path('<slug:group_slug>/members/edit', UpdateGroupMembersView.as_view(), name='update-members')
]<|code_end|>
server/apps/group/views.py
<|code_start|>from django.shortcuts import redirect, render
from django.views.generic import DetailView, UpdateView, ListView, View
from .models import Club, Group, NamedMembership
from .forms import NamedMembershipClubFormset
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.contrib.auth.mixins import UserPassesTestMixin
from apps.student.models import Student
from apps.event.models import Event
from apps.event.forms import EventGroupFormSet
class ListClubView(ListView):
model = Club
template_name = 'group/club_list.html'
class UpdateClubView(UpdateView):
model = Club
template_name = 'group/club_update.html'
fields = ['description', 'admins', 'logo']
class UpdateGroupEventsView(UserPassesTestMixin, View):
template_name = 'group/club_events_update.html'
def test_func(self):
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = Event.objects.filter(group=kwargs['group_slug'])
context['form'] = EventGroupFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
class UpdateGroupMembersView(UserPassesTestMixin, View):
template_name = 'group/club_members_update.html'
def test_func(self):
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
if isinstance(context['object'], Club):
memberships = NamedMembership.objects.filter(group=context['object'])
membersForm = NamedMembershipClubFormset(queryset=memberships)
context['members'] = membersForm
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_named_memberships(request, group_slug)
class DetailClubView(DetailView):
model = Club
template_name = 'group/club_detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
members = NamedMembership.objects.filter(group=self.object)
context['members'] = members
return context
@login_required
def add_member(request, group_slug, student_id):
"""Add a user to a club"""
group = Group.get_group_by_slug(group_slug)
student = Student.objects.get(id=student_id)
if isinstance(Club, group):
NamedMembership.objects.create(student=student, group=group)
@require_http_methods(['POST'])
@login_required
def edit_named_memberships(request, group_slug):
club = Club.objects.filter(slug=group_slug).first()
form = NamedMembershipClubFormset(request.POST)
if form.is_valid():
members = form.save(commit=False)
for member in members:
member.group = club
member.save()
for member in form.deleted_objects:
member.delete()
messages.success(request, 'Membres modifies')
return redirect('group:update', club.id)
else:
messages.warning(request, form.errors)
return redirect('group:update', club.id)
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventGroupFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
Ajouter les parents dans les groupes
Ajouter un field parent dans les groupes pour pouvoir faire des liens entre groupes
|
server/apps/group/migrations/0004_club_parent.py
<|code_start|><|code_end|>
server/apps/group/models.py
<|code_start|>from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
from django.urls.base import reverse
from apps.student.models import Student
from apps.utils.upload import PathAndRename
from model_utils.managers import InheritanceManager
TYPE_BDX = [
('BDA', 'Bureau des Arts'),
('BDE', 'Bureau des Élèves'),
('BDS', 'Bureau des Sports'),
('Asso', 'Association')
]
path_and_rename = PathAndRename("groups/logo")
class Group(models.Model):
name = models.CharField(verbose_name='Nom du groupe', unique=True, max_length=200)
description = models.TextField(verbose_name='Description du groupe', blank=True)
admins = models.ManyToManyField(Student, verbose_name='Administrateur.rice.s du groupe', related_name='admins')
members = models.ManyToManyField(Student, verbose_name='Membres du groupe', related_name='members')
logo = models.ImageField(verbose_name='Logo du groupe', blank=True, null=True, upload_to=path_and_rename)
slug = models.SlugField(max_length=40, unique=True, blank=True)
class Meta:
abstract = True
def __str__(self):
return self.name
def is_admin(self, user: User) -> bool:
"""Indicates if a user is admin."""
student = Student.objects.filter(user=user).first()
return student in self.admins.all()
@staticmethod
def get_group_by_slug(slug: str):
"""Get a group from a slug."""
type_slug = slug.split('--')[0]
if type_slug == 'club':
return Club.objects.get(slug=slug)
else:
return Group.objects.get(slug=slug)
@property
def get_absolute_url(self):
return reverse('group:detail', kwargs={'pk': self.pk})
class Club(Group):
members = models.ManyToManyField(Student, through='NamedMembership')
bdx_type = models.CharField(verbose_name='Type de club BDX', choices=TYPE_BDX, max_length=60)
def save(self, *args, **kwargs):
self.slug = f'club--{slugify(self.name)}'
super(Club, self).save(*args, **kwargs)
class NamedMembership(models.Model):
function = models.CharField(verbose_name='Poste occupé', max_length=200, blank=True)
year = models.IntegerField(verbose_name='Année du poste', blank=True, null=True)
student = models.ForeignKey(Student, on_delete=models.CASCADE)
group = models.ForeignKey(Club, on_delete=models.CASCADE)<|code_end|>
server/apps/group/views.py
<|code_start|>from django.shortcuts import redirect, render
from django.views.generic import DetailView, UpdateView, ListView, View
from .models import Club, Group, NamedMembership
from .forms import NamedMembershipClubFormset
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.contrib.auth.mixins import UserPassesTestMixin
from apps.student.models import Student
from apps.event.models import Event
from apps.event.forms import EventFormSet
class ListClubView(ListView):
model = Club
template_name = 'group/club_list.html'
class UpdateClubView(UpdateView):
model = Club
template_name = 'group/club_update.html'
fields = ['description', 'admins', 'logo']
class UpdateGroupEventsView(UserPassesTestMixin, View):
template_name = 'group/club_events_update.html'
def test_func(self):
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = Event.objects.filter(group=kwargs['group_slug'])
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
class UpdateGroupMembersView(UserPassesTestMixin, View):
template_name = 'group/club_members_update.html'
def test_func(self):
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
if isinstance(context['object'], Club):
memberships = NamedMembership.objects.filter(group=context['object'])
membersForm = NamedMembershipClubFormset(queryset=memberships)
context['members'] = membersForm
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_named_memberships(request, group_slug)
class DetailClubView(DetailView):
model = Club
template_name = 'group/club_detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
members = NamedMembership.objects.filter(group=self.object)
context['members'] = members
context['is_admin'] = self.object.is_admin(self.request.user)
context['events'] = Event.objects.filter(group=self.object.slug)
return context
@login_required
def add_member(request, group_slug, student_id):
"""Add a user to a club"""
group = Group.get_group_by_slug(group_slug)
student = Student.objects.get(id=student_id)
if isinstance(Club, group):
NamedMembership.objects.create(student=student, group=group)
@require_http_methods(['POST'])
@login_required
def edit_named_memberships(request, group_slug):
club = Club.objects.filter(slug=group_slug).first()
form = NamedMembershipClubFormset(request.POST)
if form.is_valid():
members = form.save(commit=False)
for member in members:
member.group = club
member.save()
for member in form.deleted_objects:
member.delete()
messages.success(request, 'Membres modifies')
return redirect('group:update', club.id)
else:
messages.warning(request, form.errors)
return redirect('group:update', club.id)
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
server/apps/group/migrations/0004_club_parent.py
<|code_start|># Generated by Django 3.0.5 on 2020-06-02 07:16
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('group', '0003_auto_20200601_2109'),
]
operations = [
migrations.AddField(
model_name='club',
name='parent',
field=models.SlugField(blank=True, max_length=40, null=True),
),
]
<|code_end|>
server/apps/group/models.py
<|code_start|>from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
from django.urls.base import reverse
from apps.student.models import Student
from apps.utils.upload import PathAndRename
from model_utils.managers import InheritanceManager
TYPE_BDX = [
('BDA', 'Bureau des Arts'),
('BDE', 'Bureau des Élèves'),
('BDS', 'Bureau des Sports'),
('Asso', 'Association')
]
path_and_rename = PathAndRename("groups/logo")
class Group(models.Model):
name = models.CharField(verbose_name='Nom du groupe', unique=True, max_length=200)
description = models.TextField(verbose_name='Description du groupe', blank=True)
admins = models.ManyToManyField(Student, verbose_name='Administrateur.rice.s du groupe', related_name='admins')
members = models.ManyToManyField(Student, verbose_name='Membres du groupe', related_name='members')
logo = models.ImageField(verbose_name='Logo du groupe', blank=True, null=True, upload_to=path_and_rename)
slug = models.SlugField(max_length=40, unique=True, blank=True)
parent = models.SlugField(max_length=40, blank=True, null=True)
class Meta:
abstract = True
def __str__(self):
return self.name
def is_admin(self, user: User) -> bool:
"""Indicates if a user is admin."""
student = Student.objects.filter(user=user).first()
return student in self.admins.all() or self.get_parent().is_admin(user)
@property
def get_parent(self):
"""Get the parent group of this group."""
return Group.get_group_by_slug(self.parent)
@staticmethod
def get_group_by_slug(slug: str):
"""Get a group from a slug."""
type_slug = slug.split('--')[0]
if type_slug == 'club':
return Club.objects.get(slug=slug)
else:
return Group.objects.get(slug=slug)
@property
def get_absolute_url(self):
return reverse('group:detail', kwargs={'pk': self.pk})
class Club(Group):
members = models.ManyToManyField(Student, through='NamedMembership')
bdx_type = models.CharField(verbose_name='Type de club BDX', choices=TYPE_BDX, max_length=60)
def save(self, *args, **kwargs):
self.slug = f'club--{slugify(self.name)}'
super(Club, self).save(*args, **kwargs)
class NamedMembership(models.Model):
function = models.CharField(verbose_name='Poste occupé', max_length=200, blank=True)
year = models.IntegerField(verbose_name='Année du poste', blank=True, null=True)
student = models.ForeignKey(Student, on_delete=models.CASCADE)
group = models.ForeignKey(Club, on_delete=models.CASCADE)<|code_end|>
server/apps/group/views.py
<|code_start|>from django.shortcuts import redirect, render
from django.views.generic import DetailView, UpdateView, ListView, View
from .models import Club, Group, NamedMembership
from .forms import NamedMembershipClubFormset
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from django.contrib.auth.mixins import UserPassesTestMixin
from apps.student.models import Student
from apps.event.models import Event
from apps.event.forms import EventFormSet
class ListClubView(ListView):
model = Club
template_name = 'group/club_list.html'
class UpdateClubView(UpdateView):
model = Club
template_name = 'group/club_update.html'
fields = ['description', 'admins', 'logo']
class UpdateGroupEventsView(UserPassesTestMixin, View):
template_name = 'group/club_events_update.html'
def test_func(self):
if self.request.user.is_authenticated:
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
return False
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = Event.objects.filter(group=kwargs['group_slug'])
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
class UpdateGroupMembersView(UserPassesTestMixin, View):
template_name = 'group/club_members_update.html'
def test_func(self):
if self.request.user.is_authenticated:
group = Group.get_group_by_slug(self.kwargs['group_slug'])
return group.is_admin(self.request.user)
return False
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
if isinstance(context['object'], Club):
memberships = NamedMembership.objects.filter(group=context['object'])
membersForm = NamedMembershipClubFormset(queryset=memberships)
context['members'] = membersForm
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_named_memberships(request, group_slug)
class DetailClubView(DetailView):
model = Club
template_name = 'group/club_detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
members = NamedMembership.objects.filter(group=self.object)
context['members'] = members
context['is_admin'] = self.object.is_admin(self.request.user) if self.request.user.is_authenticated else False
context['events'] = Event.objects.filter(group=self.object.slug)
return context
@login_required
def add_member(request, group_slug, student_id):
"""Add a user to a club"""
group = Group.get_group_by_slug(group_slug)
student = Student.objects.get(id=student_id)
if isinstance(Club, group):
NamedMembership.objects.create(student=student, group=group)
@require_http_methods(['POST'])
@login_required
def edit_named_memberships(request, group_slug):
club = Club.objects.filter(slug=group_slug).first()
form = NamedMembershipClubFormset(request.POST)
if form.is_valid():
members = form.save(commit=False)
for member in members:
member.group = club
member.save()
for member in form.deleted_objects:
member.delete()
messages.success(request, 'Membres modifies')
return redirect('group:update', club.id)
else:
messages.warning(request, form.errors)
return redirect('group:update', club.id)
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
Frontend events planifés et events archivés ne fonctionnent pas
Events archivés renvoit une erreur 500.
Event planifiés ne renvoit rien
|
server/apps/event/api_views.py
<|code_start|>from datetime import datetime
from rest_framework import generics
from .models import BaseEvent
from .serializers import BaseEventSerializer
class ListEventsGroupAPIView(generics.ListAPIView):
"""List events for a group depending on the chosen
time window. By default only returns current events."""
serializer_class = BaseEventSerializer
def get_queryset(self):
if self.request.method == 'GET':
if self.request.GET.get('view') == 'archives':
return BaseEvent.objects.filter(group=self.kwargs['group'], date__lt=datetime.today())
elif self.request.get('view') == 'all':
return BaseEvent.objects.filter(group=self.kwargs['group'])
return BaseEvent.objects.filter(group=self.kwargs['group'], date__gte=datetime.today())
class UpdateEventAPIView(generics.RetrieveDestroyAPIView):
serializer_class = BaseEventSerializer
lookup_field = 'slug'
lookup_url_kwarg = 'event_slug'
def get_queryset(self):
return BaseEvent.objects.filter(slug=self.kwargs['event_slug'])
<|code_end|>
server/apps/event/views.py
<|code_start|>from datetime import date
from django.shortcuts import redirect, render
from django.contrib import messages
from django.contrib.auth.models import User
from django.views.generic.base import TemplateView, View
from django.views.generic import UpdateView, FormView
from django.contrib.auth.decorators import login_required
from .models import *
from .forms import EventForm, EventFormSet
from apps.group.models import Group
from apps.utils.accessMixins import LoginRequiredAccessMixin, UserIsAdmin
class EventDetailView(LoginRequiredAccessMixin, TemplateView):
template_name = 'event/detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
self.object = BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
context['object'] = self.object
context['group'] = self.object.get_group
context['is_participating'] = self.object.is_participating(
self.request.user)
return context
class UpdateGroupCreateEventView(UserIsAdmin, FormView):
"""In the context of a group, create event view."""
template_name = 'group/event/create.html'
form_class = EventForm
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = Group.get_group_by_slug(self.kwargs['group_slug'])
return context
def form_valid(self, form, **kwargs):
event = form.save(commit=False)
event.group = Group.get_group_by_slug(
slug=self.kwargs['group_slug']).slug
event.save()
return redirect('group:create-event', self.kwargs['group_slug'])
class EventUpdateView(UserIsAdmin, UpdateView):
template_name = 'event/update.html'
fields = ['title', 'description', 'location',
'date', 'publicity', 'color', 'image']
def test_func(self) -> bool:
self.kwargs['group_slug'] = self.object.get_group.slug
return super().test_func()
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = self.object.get_group
context['event'] = self.object
return context
def get_object(self, **kwargs):
return BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
def dispatch(self, request, *args, **kwargs):
self.object = BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
self.kwargs['group_slug'] = self.object.get_group.slug
if isinstance(self.object, EatingEvent):
self.fields = ['title', 'description', 'location',
'date', 'publicity', 'color', 'image', 'menu']
return super().dispatch(request, *args, **kwargs)
class UpdateGroupEventsView(UserIsAdmin, View):
template_name = 'group/event/planned_edit.html'
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = BaseEvent.objects.filter(
group=kwargs['group_slug'], date__gte=date.today())
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
class UpdateGroupArchivedEventsView(UserIsAdmin, View):
template_name = 'group/archived_edit.html'
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = BaseEvent.objects.filter(
group=kwargs['group_slug'], date__lt=date.today())
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
@login_required
def add_participant(request, event_slug):
"""Adds the user to the list of participants."""
event = BaseEvent.get_event_by_slug(event_slug)
event.participants.add(request.user.student)
if request.GET.get('redirect'):
return redirect('home:home')
return redirect(event.get_absolute_url())
@login_required
def remove_participant(request, event_slug):
"""Removes the user from the list of participants."""
event = BaseEvent.get_event_by_slug(event_slug)
event.participants.remove(request.user.student)
if request.GET.get('redirect'):
return redirect('home:home')
return redirect(event.get_absolute_url())
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
server/apps/event/api_views.py
<|code_start|>from datetime import datetime
from rest_framework import generics
from .models import BaseEvent
from .serializers import BaseEventSerializer
class ListEventsGroupAPIView(generics.ListAPIView):
"""List events for a group depending on the chosen
time window. By default only returns current events."""
serializer_class = BaseEventSerializer
def get_queryset(self):
if self.request.method == 'GET':
if self.request.GET.get('view') == 'archives':
return BaseEvent.objects.filter(group=self.kwargs['group'], date__lt=datetime.today())
elif self.request.GET.get('view') == 'all':
return BaseEvent.objects.filter(group=self.kwargs['group'])
return BaseEvent.objects.filter(group=self.kwargs['group'], date__gte=datetime.today())
class UpdateEventAPIView(generics.RetrieveDestroyAPIView):
serializer_class = BaseEventSerializer
lookup_field = 'slug'
lookup_url_kwarg = 'event_slug'
def get_queryset(self):
return BaseEvent.objects.filter(slug=self.kwargs['event_slug'])
<|code_end|>
server/apps/event/views.py
<|code_start|>from datetime import date
from django.shortcuts import redirect, render
from django.contrib import messages
from django.contrib.auth.models import User
from django.views.generic.base import TemplateView, View
from django.views.generic import UpdateView, FormView
from django.contrib.auth.decorators import login_required
from .models import *
from .forms import EventForm, EventFormSet
from apps.group.models import Group
from apps.utils.accessMixins import LoginRequiredAccessMixin, UserIsAdmin
class EventDetailView(LoginRequiredAccessMixin, TemplateView):
template_name = 'event/detail.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
self.object = BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
context['object'] = self.object
context['group'] = self.object.get_group
context['is_participating'] = self.object.is_participating(
self.request.user)
return context
class UpdateGroupCreateEventView(UserIsAdmin, FormView):
"""In the context of a group, create event view."""
template_name = 'group/event/create.html'
form_class = EventForm
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = Group.get_group_by_slug(self.kwargs['group_slug'])
return context
def form_valid(self, form, **kwargs):
event = form.save(commit=False)
event.group = Group.get_group_by_slug(
slug=self.kwargs['group_slug']).slug
event.save()
return redirect('group:create-event', self.kwargs['group_slug'])
class EventUpdateView(UserIsAdmin, UpdateView):
template_name = 'event/update.html'
fields = ['title', 'description', 'location',
'date', 'publicity', 'color', 'image']
def test_func(self) -> bool:
self.kwargs['group_slug'] = self.object.get_group.slug
return super().test_func()
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = self.object.get_group
context['event'] = self.object
return context
def get_object(self, **kwargs):
return BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
def dispatch(self, request, *args, **kwargs):
self.object = BaseEvent.get_event_by_slug(self.kwargs['event_slug'])
self.kwargs['group_slug'] = self.object.get_group.slug
if isinstance(self.object, EatingEvent):
self.fields = ['title', 'description', 'location',
'date', 'publicity', 'color', 'image', 'menu']
return super().dispatch(request, *args, **kwargs)
class UpdateGroupEventsView(UserIsAdmin, View):
template_name = 'group/event/planned_edit.html'
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = BaseEvent.objects.filter(
group=kwargs['group_slug'], date__gte=date.today())
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
class UpdateGroupArchivedEventsView(UserIsAdmin, View):
template_name = 'group/event/archived_edit.html'
def get_context_data(self, **kwargs):
context = {}
context['object'] = Group.get_group_by_slug(kwargs['group_slug'])
context['events'] = BaseEvent.objects.filter(
group=kwargs['group_slug'], date__lte=date.today())
context['form'] = EventFormSet(queryset=context['events'])
return context
def get(self, request, group_slug):
return render(request, self.template_name, context=self.get_context_data(group_slug=group_slug))
def post(self, request, group_slug):
return edit_events(request, group_slug)
@login_required
def add_participant(request, event_slug):
"""Adds the user to the list of participants."""
event = BaseEvent.get_event_by_slug(event_slug)
event.participants.add(request.user.student)
if request.GET.get('redirect'):
return redirect('home:home')
return redirect(event.get_absolute_url())
@login_required
def remove_participant(request, event_slug):
"""Removes the user from the list of participants."""
event = BaseEvent.get_event_by_slug(event_slug)
event.participants.remove(request.user.student)
if request.GET.get('redirect'):
return redirect('home:home')
return redirect(event.get_absolute_url())
@login_required
def edit_events(request, group_slug):
group = Group.get_group_by_slug(group_slug)
form = EventFormSet(request.POST)
if form.is_valid():
events = form.save(commit=False)
# Link each event to the group
for event in events:
event.group = group.slug
event.save()
# Delete missing events
for event in form.deleted_objects:
event.delete()
messages.success(request, 'Events modifies')
return redirect('group:update-events', group_slug)
else:
messages.warning(request, form.errors)
return redirect('group:update-events', group_slug)
<|code_end|>
|
Mot de passe perdu
Cette fonctionnalité de fonctionne pas sur mon ordinateur mais fonctionne sur l'ordinateur de Gabin Schieffer <br/> Proposé par [email protected]
|
server/apps/account/urls.py
<|code_start|>from django.conf.urls import url
from django.urls import path
from .views import *
app_name = 'account'
urlpatterns = [
path('login', AuthView.as_view(), name='login'),
path('logout', LogoutView.as_view(), name='logout'),
path('registration', RegistrationView.as_view(), name='registration'),
path('registration/temporary/<int:id>/approve', ApproveTemporaryRegistrationView.as_view(),
name='temp-req-approve'),
path('registration/temporary/<int:id>/deny', DenyTemporaryRegistrationView.as_view(),
name='temp-req-deny'),
path('registration/temporary', TemporaryRegistrationView.as_view(),
name='temporary-registration'),
path('activate/<slug:uidb64>/<slug:token>/',
ConfirmUser.as_view(), name='confirm'),
path('activate/<slug:uidb64>/<slug:token>/temporary',
ConfirmUserTemporary.as_view(), name='confirm-temporary'),
path('permanent', PermanentAccountUpgradeView.as_view(),
name='upgrade-permanent'),
path('forgotten', ForgottenPassView.as_view(), name='forgotten_pass'),
path('reset_pass/<slug:uidb64>/<slug:token>',
PasswordResetConfirmCustomView.as_view(), name='reset_pass'),
path('<slug:user_id>/student', redirect_to_student, name='redirect-student'),
]
<|code_end|>
server/apps/account/views.py
<|code_start|>from datetime import date
from typing import Any, Dict, Union
from django.conf import settings
from django.contrib.auth import login, logout
from django.contrib.sites.shortcuts import get_current_site
from django.http.response import HttpResponse
from django.views.generic.edit import FormView
from django.shortcuts import get_object_or_404
from apps.utils.accessMixins import UserIsSuperAdmin
from .forms import SignUpForm, LoginForm, ForgottenPassForm, TemporaryRequestSignUpForm, UpgradePermanentAccountForm
from .tokens import account_activation_token
from django.contrib import messages
from django.shortcuts import render, redirect
from django.template.loader import render_to_string
from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
from django.utils.encoding import force_bytes, force_text
from django.urls import reverse, reverse_lazy
from django.contrib.auth.views import PasswordResetConfirmView
from django.views import View
from django.contrib.auth.forms import SetPasswordForm
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.models import User
from apps.student.models import Student
from .emailAuthBackend import EmailBackend
from .models import TemporaryAccessRequest
from .utils import user_creation, send_email_confirmation
class RegistrationView(FormView):
template_name = 'account/registration.html'
form_class = SignUpForm
def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
context['temporary_registration'] = settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today()
return context
def form_valid(self, form):
user_creation(form, self.request)
return redirect(reverse('home:home'))
class TemporaryRegistrationView(FormView):
form_class = TemporaryRequestSignUpForm
template_name = 'account/temporary_registration.html'
def dispatch(self, request, *args: Any, **kwargs: Any):
"""Do not allow to use this view outside of allowed temporary accounts windows."""
if not settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today():
return redirect(reverse('account:registration'))
return super().dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
context['DEADLINE_TEMPORARY_REGISTRATION'] = settings.TEMPORARY_ACCOUNTS_DATE_LIMIT
return context
def form_valid(self, form) -> HttpResponse:
user_creation(form, self.request)
return redirect(reverse('home:home'))
class ConfirmUser(View):
def get(self, request, uidb64, token):
tempAccessReq: Union[TemporaryAccessRequest, None] = None
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
return render(self.request, 'account/activation_invalid.html')
# checking if the user is not a temporary one
try:
tempAccessReq: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user.pk)
if not tempAccessReq.approved:
return render(self.request, 'account/activation_invalid.html')
except TemporaryAccessRequest.DoesNotExist:
tempAccessReq = None
# checking if the token is valid.
if account_activation_token.check_token(user, token):
# if valid set active true
user.is_active = True
if tempAccessReq is not None:
user.email = tempAccessReq.final_email
tempAccessReq.delete()
messages.warning(
request, f'Dorénavant vous devez utiliser {user.email} pour vous connecter.')
user.save()
login(self.request, user,
backend='apps.account.emailAuthBackend.EmailBackend')
messages.success(request, 'Votre compte est desormais actif !')
return redirect(reverse('home:home'))
else:
return render(self.request, 'account/activation_invalid.html')
class AuthView(FormView):
template_name = 'account/login.html'
form_class = LoginForm
def get(self, request):
if request.user.is_authenticated:
user = request.user
message = f'Vous etes déjà connecté en tant que {user.first_name.title()}.'
messages.warning(request, message)
return redirect(reverse('home:home'))
else:
return super(AuthView, AuthView).get(self, request)
def form_invalid(self, form):
message = f'Veuillez vous connecter avec votre adresse mail ECN.'
messages.warning(self.request, message)
return redirect(reverse('account:login'))
def form_valid(self, form):
username = form.cleaned_data['email']
password = form.cleaned_data['password']
user = EmailBackend.authenticate(username=username, password=password)
if user is not None:
if user.is_active:
message = f'Bonjour {user.first_name.title()} !'
messages.success(self.request, message)
else:
if settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today():
# During certain periods allow temporary accounts.
try:
temporaryAccessRequest: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user
)
if not temporaryAccessRequest.mail_valid:
message = 'Votre compte n\'est pas encore actif.\
Veuillez cliquer sur le lien envoyé par mail pour l\'\
activer.'
messages.error(self.request, message)
return redirect(reverse('account:login'))
if temporaryAccessRequest.approved_until <= date.today():
message = 'Votre compte n\'a pas encore été approuvé.\
On vous prévient par mail dès que c\'est le cas.'
messages.error(self.request, message)
return redirect(reverse('account:login'))
message = f'Votre compte n\'est pas encore définitif.\
Veuillez le valider <a href="{reverse("account:upgrade-permanent")}">ici</a>.\
Attention après le {temporaryAccessRequest.approved_until}\
vous ne pourrez plus vous connecter si vous n\'avez pas renseigné votre adresse Centrale.'
messages.warning(self.request, message)
except TemporaryAccessRequest.DoesNotExist:
messages.error(
self.request, 'Identifiant inconnu ou mot de passe invalide.')
return redirect(reverse('account:login'))
else:
messages.warning(
self.request, 'Votre compte n\'est pas encore actif. Veuillez cliquer sur le lien dans \'email.')
login(self.request, user,
backend='apps.account.emailAuthBackend.EmailBackend')
return redirect(reverse('home:home'))
else:
messages.error(
self.request, 'Identifiant inconnu ou mot de passe invalide.')
return redirect(reverse('account:login'))
class LogoutView(View):
def get(self, request):
logout(request)
messages.success(request, 'Vous avez été déconnecté.')
return redirect(reverse('account:login'))
class ForgottenPassView(FormView):
form_class = ForgottenPassForm
template_name = 'account/forgotten_pass.html'
def form_valid(self, form):
user = User.objects.get(email=form.cleaned_data['email'])
if user is not None:
subject = '[Nantral Platform] Reinitialisation de votre mot de passe'
current_site = get_current_site(self.request)
message = render_to_string('account/mail/password_request.html', {
'user': user,
'domain': current_site.domain,
'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),
# method will generate a hash value with user related data
'token': account_activation_token.make_token(user),
})
user.email_user(
subject, message, '[email protected]', html_message=message)
messages.success(
self.request, 'Un email de récuperation a été envoyé si cette adresse existe.')
return redirect(reverse('account:login'))
class PasswordResetConfirmCustomView(PasswordResetConfirmView):
template_name = 'account/reset_password.html'
post_reset_login = True
post_reset_login_backend = 'apps.account.emailAuthBackend.EmailBackend'
form_class = SetPasswordForm
token_generator = account_activation_token
success_url = reverse_lazy('home:home')
def redirect_to_student(request, user_id):
user = User.objects.get(id=user_id)
student = Student.objects.get(user=user)
return redirect('student:update', student.pk)
class ABCApprovalTemporaryResgistrationView(UserIsSuperAdmin, View):
def get(self, request, id):
self.temp_req: TemporaryAccessRequest = get_object_or_404(
TemporaryAccessRequest, id=id)
if self.temp_req.approved:
messages.warning(request, f'Cette requête a déjà été approuvée.')
return redirect(reverse('home:home'))
class ApproveTemporaryRegistrationView(ABCApprovalTemporaryResgistrationView):
def get(self, request, id):
super().get(request, id)
self.temp_req.approve()
messages.success(
request, f'Vous avez accepté la demande de {self.temp_req.user.first_name} {self.temp_req.user.last_name}')
return redirect(reverse('home:home'))
class DenyTemporaryRegistrationView(ABCApprovalTemporaryResgistrationView):
def get(self, request, id):
super().get(request, id)
messages.success(
request, f'Vous avez refusé la demande de {self.temp_req.user.first_name} {self.temp_req.user.last_name}')
self.temp_req.deny()
return redirect(reverse('home:home'))
class ConfirmUserTemporary(View):
def get(self, request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
# checking if the user exists, if the token is valid.
if user is not None and account_activation_token.check_token(user, token):
try:
temp_req: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user)
temp_req.mail_valid = True
temp_req.save()
except TemporaryAccessRequest.DoesNotExist:
return render(self.request, 'account/activation_invalid.html')
messages.success(request, 'Votre addresse mail est confirmé! \n\
Comme vous n\'avez pas utilisé votre adresse Centrale, vous devez encore attendre qu\'un administrateur vérifie votre inscription.\n\
On vous prévient par mail dès que c\'est bon!. ')
return redirect(reverse('home:home'))
else:
return render(self.request, 'account/activation_invalid.html')
class PermanentAccountUpgradeView(LoginRequiredMixin, FormView):
form_class = UpgradePermanentAccountForm
template_name = 'account/permanent_account_upgrade.html'
success_url = reverse_lazy('home:home')
def get(self, request):
get_object_or_404(
TemporaryAccessRequest,
user=self.request.user
)
return super().get(request)
def form_valid(self, form: UpgradePermanentAccountForm) -> HttpResponse:
temp_request = get_object_or_404(
TemporaryAccessRequest,
user=self.request.user
)
temp_request.final_email = form.cleaned_data['email']
temp_request.save()
send_email_confirmation(
self.request.user, self.request, send_to=form.cleaned_data['email'])
return super().form_valid(form)
<|code_end|>
|
server/apps/account/urls.py
<|code_start|>from django.conf.urls import url
from django.urls import path
from .views import *
app_name = 'account'
urlpatterns = [
path('login', AuthView.as_view(), name='login'),
path('logout', LogoutView.as_view(), name='logout'),
path('registration', RegistrationView.as_view(), name='registration'),
path('registration/temporary/<int:id>/approve', ApproveTemporaryRegistrationView.as_view(),
name='temp-req-approve'),
path('registration/temporary/<int:id>/deny', DenyTemporaryRegistrationView.as_view(),
name='temp-req-deny'),
path('registration/temporary', TemporaryRegistrationView.as_view(),
name='temporary-registration'),
path('activate/<slug:uidb64>/<slug:token>/',
ConfirmUser.as_view(), name='confirm'),
path('activate/<slug:uidb64>/<slug:token>/temporary',
ConfirmUserTemporary.as_view(), name='confirm-temporary'),
path('permanent', PermanentAccountUpgradeView.as_view(),
name='upgrade-permanent'),
path('forgotten', ForgottenPassView.as_view(), name='forgotten_pass'),
path('reset_pass/<slug:uidb64>/<slug:token>/',
PasswordResetConfirmCustomView.as_view(), name='reset_pass'),
path('<slug:user_id>/student', redirect_to_student, name='redirect-student'),
]
<|code_end|>
server/apps/account/views.py
<|code_start|>from datetime import date
from typing import Any, Dict, Union
from django.conf import settings
from django.contrib.auth import login, logout
from django.contrib.sites.shortcuts import get_current_site
from django.http.response import HttpResponse
from django.views.generic.edit import FormView
from django.shortcuts import get_object_or_404
from apps.utils.accessMixins import UserIsSuperAdmin
from .forms import SignUpForm, LoginForm, ForgottenPassForm, TemporaryRequestSignUpForm, UpgradePermanentAccountForm
from .tokens import account_activation_token
from django.contrib import messages
from django.shortcuts import render, redirect
from django.template.loader import render_to_string
from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
from django.utils.encoding import force_bytes, force_text
from django.urls import reverse, reverse_lazy
from django.contrib.auth.views import PasswordResetConfirmView
from django.views import View
from django.contrib.auth.forms import SetPasswordForm
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.models import User
from apps.student.models import Student
from .emailAuthBackend import EmailBackend
from .models import TemporaryAccessRequest
from .utils import user_creation, send_email_confirmation
class RegistrationView(FormView):
template_name = 'account/registration.html'
form_class = SignUpForm
def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
context['temporary_registration'] = settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today()
return context
def form_valid(self, form):
user_creation(form, self.request)
return redirect(reverse('home:home'))
class TemporaryRegistrationView(FormView):
form_class = TemporaryRequestSignUpForm
template_name = 'account/temporary_registration.html'
def dispatch(self, request, *args: Any, **kwargs: Any):
"""Do not allow to use this view outside of allowed temporary accounts windows."""
if not settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today():
return redirect(reverse('account:registration'))
return super().dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs: Any) -> Dict[str, Any]:
context = super().get_context_data(**kwargs)
context['DEADLINE_TEMPORARY_REGISTRATION'] = settings.TEMPORARY_ACCOUNTS_DATE_LIMIT
return context
def form_valid(self, form) -> HttpResponse:
user_creation(form, self.request)
return redirect(reverse('home:home'))
class ConfirmUser(View):
def get(self, request, uidb64, token):
tempAccessReq: Union[TemporaryAccessRequest, None] = None
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
return render(self.request, 'account/activation_invalid.html')
# checking if the user is not a temporary one
try:
tempAccessReq: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user.pk)
if not tempAccessReq.approved:
return render(self.request, 'account/activation_invalid.html')
except TemporaryAccessRequest.DoesNotExist:
tempAccessReq = None
# checking if the token is valid.
if account_activation_token.check_token(user, token):
# if valid set active true
user.is_active = True
if tempAccessReq is not None:
user.email = tempAccessReq.final_email
tempAccessReq.delete()
messages.warning(
request, f'Dorénavant vous devez utiliser {user.email} pour vous connecter.')
user.save()
login(self.request, user,
backend='apps.account.emailAuthBackend.EmailBackend')
messages.success(request, 'Votre compte est desormais actif !')
return redirect(reverse('home:home'))
else:
return render(self.request, 'account/activation_invalid.html')
class AuthView(FormView):
template_name = 'account/login.html'
form_class = LoginForm
def get(self, request):
if request.user.is_authenticated:
user = request.user
message = f'Vous etes déjà connecté en tant que {user.first_name.title()}.'
messages.warning(request, message)
return redirect(reverse('home:home'))
else:
return super(AuthView, AuthView).get(self, request)
def form_invalid(self, form):
message = f'Veuillez vous connecter avec votre adresse mail ECN.'
messages.warning(self.request, message)
return redirect(reverse('account:login'))
def form_valid(self, form):
username = form.cleaned_data['email']
password = form.cleaned_data['password']
user = EmailBackend.authenticate(username=username, password=password)
if user is not None:
if user.is_active:
message = f'Bonjour {user.first_name.title()} !'
messages.success(self.request, message)
else:
if settings.TEMPORARY_ACCOUNTS_DATE_LIMIT >= date.today():
# During certain periods allow temporary accounts.
try:
temporaryAccessRequest: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user
)
if not temporaryAccessRequest.mail_valid:
message = 'Votre compte n\'est pas encore actif.\
Veuillez cliquer sur le lien envoyé par mail pour l\'\
activer.'
messages.error(self.request, message)
return redirect(reverse('account:login'))
if temporaryAccessRequest.approved_until <= date.today():
message = 'Votre compte n\'a pas encore été approuvé.\
On vous prévient par mail dès que c\'est le cas.'
messages.error(self.request, message)
return redirect(reverse('account:login'))
message = f'Votre compte n\'est pas encore définitif.\
Veuillez le valider <a href="{reverse("account:upgrade-permanent")}">ici</a>.\
Attention après le {temporaryAccessRequest.approved_until}\
vous ne pourrez plus vous connecter si vous n\'avez pas renseigné votre adresse Centrale.'
messages.warning(self.request, message)
except TemporaryAccessRequest.DoesNotExist:
messages.error(
self.request, 'Identifiant inconnu ou mot de passe invalide.')
return redirect(reverse('account:login'))
else:
messages.warning(
self.request, 'Votre compte n\'est pas encore actif. Veuillez cliquer sur le lien dans \'email.')
login(self.request, user,
backend='apps.account.emailAuthBackend.EmailBackend')
return redirect(reverse('home:home'))
else:
messages.error(
self.request, 'Identifiant inconnu ou mot de passe invalide.')
return redirect(reverse('account:login'))
class LogoutView(View):
def get(self, request):
logout(request)
messages.success(request, 'Vous avez été déconnecté.')
return redirect(reverse('account:login'))
class ForgottenPassView(FormView):
form_class = ForgottenPassForm
template_name = 'account/forgotten_pass.html'
def form_valid(self, form):
try:
user = User.objects.get(email=form.cleaned_data['email'])
if user is not None:
subject = '[Nantral Platform] Reinitialisation de votre mot de passe'
current_site = get_current_site(self.request)
message = render_to_string('account/mail/password_request.html', {
'user': user,
'domain': current_site.domain,
'uidb64': urlsafe_base64_encode(force_bytes(user.pk)),
# method will generate a hash value with user related data
'token': account_activation_token.make_token(user),
})
user.email_user(
subject, message, '[email protected]', html_message=message)
except User.DoesNotExist:
pass
messages.success(
self.request, 'Un email de récuperation a été envoyé si cette adresse existe.')
return redirect(reverse('account:login'))
class PasswordResetConfirmCustomView(PasswordResetConfirmView):
template_name = 'account/reset_password.html'
post_reset_login = True
post_reset_login_backend = 'apps.account.emailAuthBackend.EmailBackend'
form_class = SetPasswordForm
token_generator = account_activation_token
success_url = reverse_lazy('home:home')
def redirect_to_student(request, user_id):
user = User.objects.get(id=user_id)
student = Student.objects.get(user=user)
return redirect('student:update', student.pk)
class ABCApprovalTemporaryResgistrationView(UserIsSuperAdmin, View):
def get(self, request, id):
self.temp_req: TemporaryAccessRequest = get_object_or_404(
TemporaryAccessRequest, id=id)
if self.temp_req.approved:
messages.warning(request, f'Cette requête a déjà été approuvée.')
return redirect(reverse('home:home'))
class ApproveTemporaryRegistrationView(ABCApprovalTemporaryResgistrationView):
def get(self, request, id):
super().get(request, id)
self.temp_req.approve()
messages.success(
request, f'Vous avez accepté la demande de {self.temp_req.user.first_name} {self.temp_req.user.last_name}')
return redirect(reverse('home:home'))
class DenyTemporaryRegistrationView(ABCApprovalTemporaryResgistrationView):
def get(self, request, id):
super().get(request, id)
messages.success(
request, f'Vous avez refusé la demande de {self.temp_req.user.first_name} {self.temp_req.user.last_name}')
self.temp_req.deny()
return redirect(reverse('home:home'))
class ConfirmUserTemporary(View):
def get(self, request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
# checking if the user exists, if the token is valid.
if user is not None and account_activation_token.check_token(user, token):
try:
temp_req: TemporaryAccessRequest = TemporaryAccessRequest.objects.get(
user=user)
temp_req.mail_valid = True
temp_req.save()
except TemporaryAccessRequest.DoesNotExist:
return render(self.request, 'account/activation_invalid.html')
messages.success(request, 'Votre addresse mail est confirmé! \n\
Comme vous n\'avez pas utilisé votre adresse Centrale, vous devez encore attendre qu\'un administrateur vérifie votre inscription.\n\
On vous prévient par mail dès que c\'est bon!. ')
return redirect(reverse('home:home'))
else:
return render(self.request, 'account/activation_invalid.html')
class PermanentAccountUpgradeView(LoginRequiredMixin, FormView):
form_class = UpgradePermanentAccountForm
template_name = 'account/permanent_account_upgrade.html'
success_url = reverse_lazy('home:home')
def get(self, request):
get_object_or_404(
TemporaryAccessRequest,
user=self.request.user
)
return super().get(request)
def form_valid(self, form: UpgradePermanentAccountForm) -> HttpResponse:
temp_request = get_object_or_404(
TemporaryAccessRequest,
user=self.request.user
)
temp_request.final_email = form.cleaned_data['email']
temp_request.save()
send_email_confirmation(
self.request.user, self.request, send_to=form.cleaned_data['email'])
return super().form_valid(form)
<|code_end|>
|
Pages lentes
Certaines pages sont un peu lentes à charger:
- liste des clubs
C'est peut-être lié au grand nombre d'images, il faudrait étudier la possibilité de cacher ces images.
|
server/apps/club/views.py
<|code_start|>from django.views.generic import ListView, TemplateView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import resolve
from apps.club.models import Club, BDX
from apps.group.models import Group
from apps.group.views import BaseDetailGroupView
from apps.utils.slug import *
class ListClubView(TemplateView):
template_name = 'club/list.html'
def get_context_data(self, **kwargs):
context = {'club_list': [] }
try:
context['club_list'].append({
'grouper': "Mes Clubs et Assos",
'list': Club.objects.filter(members__user=self.request.user).only('name', 'slug', 'logo', 'bdx_type'),
})
except Exception:
pass
club_list = Club.objects.all().select_related('bdx_type').only('name', 'slug', 'logo', 'bdx_type')
context['club_list'].append({
'grouper': "Associations",
'list': club_list.filter(bdx_type__isnull=True)
})
for bdx in BDX.objects.all():
context['club_list'].append({
'grouper': f'Clubs {bdx.name}',
'list': club_list.filter(bdx_type=bdx),
})
return context
class DetailClubView(BaseDetailGroupView):
'''Vue de détails d'un club.'''
template_name='club/detail.html'
class DetailGroupMembersView(LoginRequiredMixin, ListView):
template_name = 'club/members.html'
def get_object(self, **kwargs):
app = resolve(self.request.path).app_name
slug = self.kwargs.get("slug")
return get_object_from_slug(app, slug)
def get_queryset(self, **kwargs):
object = self.get_object()
members = object.members.through.objects.filter(group=object)
return members.order_by('year', 'order')
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = self.get_object()
return context
<|code_end|>
|
server/apps/club/views.py
<|code_start|>from django.views.generic import ListView, TemplateView
from django.contrib.auth.mixins import LoginRequiredMixin
from django.urls import resolve
from apps.club.models import Club
from apps.group.views import BaseDetailGroupView
from apps.utils.slug import *
class ListClubView(TemplateView):
template_name = 'club/list.html'
def get_context_data(self, **kwargs):
context = {'club_list': {} }
clubList = {}
allMembersClub = Club.objects.filter(members__user=self.request.user).only('name', 'slug', 'logo', 'bdx_type')
for club in allMembersClub:
clubList.setdefault("Mes Clubs et Assos", []).append(club)
allClubs = Club.objects.all().select_related("bdx_type").only('name', 'slug', 'logo', 'bdx_type')
for club in allClubs:
if(club.bdx_type is None):
clubList.setdefault("Associations", []).append(club)
else:
clubList.setdefault(f'Clubs {club.bdx_type.name}', []).append(club)
context['club_list']=clubList
return context
class DetailClubView(BaseDetailGroupView):
'''Vue de détails d'un club.'''
template_name='club/detail.html'
class DetailGroupMembersView(LoginRequiredMixin, ListView):
template_name = 'club/members.html'
def get_object(self, **kwargs):
app = resolve(self.request.path).app_name
slug = self.kwargs.get("slug")
return get_object_from_slug(app, slug)
def get_queryset(self, **kwargs):
object = self.get_object()
members = object.members.through.objects.filter(group=object)
return members.order_by('year', 'order')
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['object'] = self.get_object()
return context
<|code_end|>
|
Problème avec les liens vers les auteur.ic.es des suggestions
Quand quelqu'un fait une suggestion depuis le site, le lien pour avoir le nom de la personne ne fonctionne pas.
|
server/apps/home/forms.py
<|code_start|>from django import forms
class SuggestionForm(forms.Form):
title = forms.CharField(max_length=50, required=True)
description = forms.CharField(widget=forms.Textarea)
<|code_end|>
server/apps/home/views.py
<|code_start|>from datetime import *
from typing import List
from django.contrib.sites.shortcuts import get_current_site
from django.db.models.query import QuerySet
from django.shortcuts import render, redirect
from django.views.generic import TemplateView, FormView
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from apps.event.models import BaseEvent
from apps.post.models import Post
from apps.utils.github import create_issue
from .forms import SuggestionForm
class HomeView(LoginRequiredMixin, TemplateView):
template_name = 'home/home.html'
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super().get_context_data(**kwargs)
posts: List[Post] = Post.objects.filter(
publication_date__gte=date.today()-timedelta(days=10)).order_by('-publication_date')
context['posts'] = [
post for post in posts if post.can_view(self.request.user)]
return context
class SuggestionView(LoginRequiredMixin, FormView):
template_name = 'home/suggestions.html'
form_class = SuggestionForm
def form_valid(self, form):
create_issue(
title=form.cleaned_data['title'],
body=f"{form.cleaned_data['description']} <br/> <a href='http://{get_current_site(self.request)}{self.request.user.student.get_absolute_url}'>Clique pour découvrir qui propose ça.</a>"
)
messages.success(
self.request, 'Votre suggestion a été enregistrée merci')
return redirect('home:home')
def handler404(request, *args, **argv):
response = render(request, '404.html', context={}, status=404)
return response
def handler500(request, *args, **argv):
response = render(request, '500.html', context={},
status=500)
return response
def event_sort(events, request):
tri = {}
jours = ["Lundi", "Mardi", "Mercredi",
"Jeudi", "Vendredi", "Samedi", "Dimanche"]
mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin",
"Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]
for event in events:
if event.date.date() == date.today():
if "Aujourd'hui" in tri:
tri["Aujourd'hui"].append(
(event, event.is_participating(request.user)))
else:
tri["Aujourd'hui"] = list()
tri["Aujourd'hui"].append(
(event, event.is_participating(request.user)))
elif event.date.date() == (date.today()+timedelta(days=1)):
if "Demain" in tri:
tri["Demain"].append(
(event, event.is_participating(request.user)))
else:
tri["Demain"] = list()
tri["Demain"].append(
(event, event.is_participating(request.user)))
else:
written_date = jours[event.date.weekday(
)] + " " + str(event.date.day) + " " + mois[event.date.month-1]
if written_date in tri:
tri[written_date].append(
(event, event.is_participating(request.user)))
else:
tri[written_date] = list()
tri[written_date].append(
(event, event.is_participating(request.user)))
return tri
<|code_end|>
server/apps/utils/github.py
<|code_start|>import requests
from django.conf import settings
def create_issue(title: str, body: str):
issue = {
'title': title,
'body': body
}
resp = requests.post(f'https://api.github.com/repos/{settings.GITHUB_REPO}/issues',
json=issue, auth=(settings.GITHUB_USER, settings.GITHUB_TOKEN))
if resp.status_code != 201:
raise Exception(f'Error while posting issue to Github: {resp.reason}')
return resp.json()['number']
def close_issue(number: int):
"""Function to close an issue in the repo."""
update = {'state': 'closed'}
requests.post(f'https://api.github.com/repos/{settings.GITHUB_REPO}/issues/{number}',
json=update, auth=(settings.GITHUB_USER, settings.GITHUB_TOKEN))
<|code_end|>
|
server/apps/home/forms.py
<|code_start|>from django import forms
TYPE_CHOICES = (
(1, ("Bug")),
(2, ("Suggestion"))
)
class SuggestionForm(forms.Form):
title = forms.CharField(max_length=50, required=True)
description = forms.CharField(widget=forms.Textarea)
suggestionOrBug = forms.ChoiceField(label="Type",
choices=TYPE_CHOICES,
required=True)
<|code_end|>
server/apps/home/views.py
<|code_start|>from datetime import *
from typing import List
from django.contrib.sites.shortcuts import get_current_site
from django.db.models.query import QuerySet
from django.shortcuts import render, redirect
from django.views.generic import TemplateView, FormView
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from apps.event.models import BaseEvent
from apps.post.models import Post
from apps.utils.github import create_issue
from .forms import SuggestionForm
class HomeView(LoginRequiredMixin, TemplateView):
template_name = 'home/home.html'
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super().get_context_data(**kwargs)
posts: List[Post] = Post.objects.filter(
publication_date__gte=date.today()-timedelta(days=10)).order_by('-publication_date')
context['posts'] = [
post for post in posts if post.can_view(self.request.user)]
return context
class SuggestionView(LoginRequiredMixin, FormView):
template_name = 'home/suggestions.html'
form_class = SuggestionForm
def form_valid(self, form):
create_issue(
title=form.cleaned_data['title'],
body=f"{form.cleaned_data['description']} <br/> [Clique pour découvrir qui propose ça.](http://{get_current_site(self.request)}{self.request.user.student.get_absolute_url()})",
label=form.cleaned_data['suggestionOrBug']
)
messages.success(
self.request, 'Votre suggestion a été enregistrée merci')
return redirect('home:home')
def handler404(request, *args, **argv):
response = render(request, '404.html', context={}, status=404)
return response
def handler500(request, *args, **argv):
response = render(request, '500.html', context={},
status=500)
return response
def event_sort(events, request):
tri = {}
jours = ["Lundi", "Mardi", "Mercredi",
"Jeudi", "Vendredi", "Samedi", "Dimanche"]
mois = ["Janvier", "Février", "Mars", "Avril", "Mai", "Juin",
"Juillet", "Août", "Septembre", "Octobre", "Novembre", "Décembre"]
for event in events:
if event.date.date() == date.today():
if "Aujourd'hui" in tri:
tri["Aujourd'hui"].append(
(event, event.is_participating(request.user)))
else:
tri["Aujourd'hui"] = list()
tri["Aujourd'hui"].append(
(event, event.is_participating(request.user)))
elif event.date.date() == (date.today()+timedelta(days=1)):
if "Demain" in tri:
tri["Demain"].append(
(event, event.is_participating(request.user)))
else:
tri["Demain"] = list()
tri["Demain"].append(
(event, event.is_participating(request.user)))
else:
written_date = jours[event.date.weekday(
)] + " " + str(event.date.day) + " " + mois[event.date.month-1]
if written_date in tri:
tri[written_date].append(
(event, event.is_participating(request.user)))
else:
tri[written_date] = list()
tri[written_date].append(
(event, event.is_participating(request.user)))
return tri
<|code_end|>
server/apps/utils/github.py
<|code_start|>import requests
from django.conf import settings
def create_issue(title: str, body: str, label):
label = "bug" if int(label) == 1 else "suggestion"
issue = {
'title': title,
'body': body,
'labels': [label]
}
resp = requests.post(f'https://api.github.com/repos/{settings.GITHUB_REPO}/issues',
json=issue, auth=(settings.GITHUB_USER, settings.GITHUB_TOKEN))
if resp.status_code != 201:
raise Exception(
f'Error while posting issue to Github: {resp.reason}')
return resp.json()['number']
def close_issue(number: int):
"""Function to close an issue in the repo."""
update = {'state': 'closed'}
requests.post(f'https://api.github.com/repos/{settings.GITHUB_REPO}/issues/{number}',
json=update, auth=(settings.GITHUB_USER, settings.GITHUB_TOKEN))
<|code_end|>
|
[Colocs] Bug d'affichage des adresses avec une coloc future
Si on ajoute une coloc avec une date de début dans le futur, elle devient la dernière coloc associée à cette adresse, et comme elle n'est pas encore occupée, elle disparaît de la carte
|
server/apps/roommates/api_views.py
<|code_start|>from rest_framework import generics, permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView
from .serializers import HousingLastRoommatesSerializer #HousingSerializer, RoommatesGroupSerializer, RoommatesMemberSerializer
from .models import Housing, NamedMembershipRoommates, Roommates
from apps.student.models import Student
from apps.utils.geocoding import geocode
from django.utils import timezone
from django.db.models import Q
class SearchGeocodingView(APIView):
"""A view to query the external Geocoding service."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request):
return Response(data=geocode(request.GET.get("search_string")))
class HousingView(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingLastRoommatesSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
now = timezone.now()
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | (Q(roommates__members=None))).distinct()
return query
class CheckAddressView(APIView):
"""An API view to wether wether a housing already exists at selected address.
Returns the pk if it does, None otherwise"""
permission_classes = [permissions.IsAuthenticated]
def post(self, request):
query = Housing.objects.filter(address=request.data.get("address"))
data = [{
'pk':housing.pk,
'name': f'{housing.address} - {housing.details} ({housing.last_roommates})'
} for housing in query ]
return Response(data=data)
'''
class HousingView(generics.ListCreateAPIView):
serializer_class = HousingSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Housing.objects.all()
class HousingRoommates(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
now = timezone.now()
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | (Q(roommates__members=None))).distinct()
return query
class RoommatesGroupView(generics.ListCreateAPIView):
"""API View to get all the groups of roommates that lived in a house."""
serializer_class = RoommatesGroupSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Roommates.objects.filter(housing=self.kwargs['pk'])
def create(self, request, *args, **kwargs):
housing = generics.get_object_or_404(Housing, pk=self.kwargs['pk'])
copy = request.data.copy()
copy['housing'] = housing.pk
serializer = self.get_serializer(
data=copy)
# Due to the fact that the student field in the NamedMembershipRoommates Serializer
# has to be read_only, the student id is passed as an attribute of the serializer
# otherwise it would be cleaned out in the validated data.
serializer.members = [] if not request.data['add_me'] else [
{
'student': request.user.student.id,
'nickname': request.data['nickname'],
}
]
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class RoommatesMembersView(generics.ListCreateAPIView):
"""API View to list members of a roommates group."""
serializer_class = RoommatesMemberSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return NamedMembershipRoommates.objects.filter(roommates=self.kwargs['pk'])
def create(self, request, *args, **kwargs):
group = generics.get_object_or_404(
Roommates, id=self.kwargs['pk'])
copy = request.data.copy()
copy['group'] = group.id
student = generics.get_object_or_404(
Student, id=request.data['student'])
serializer = self.get_serializer(data=copy)
serializer.student = student
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class RoommatesGroupEditView(generics.RetrieveUpdateDestroyAPIView):
"""API View to update or delete a roommates group."""
serializer_class = RoommatesGroupSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Roommates.objects.filter(id=self.kwargs['pk'])
class RoommatesMemberView(generics.RetrieveUpdateDestroyAPIView):
"""API View to get a specific membership and update or delete it."""
serializer_class = RoommatesMemberSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return NamedMembershipRoommates.objects.filter(id=self.kwargs['pk'])
'''<|code_end|>
server/apps/roommates/models.py
<|code_start|>from django.db import models
from datetime import date
from apps.group.models import Group, NamedMembership
from apps.student.models import Student
from apps.utils.geocoding import geocode
class Housing(models.Model):
address = models.CharField(
max_length=250, verbose_name='Adresse')
details = models.CharField(
max_length=100, verbose_name='Complément d\'adresse', null=True, blank=True)
latitude = models.FloatField(null=True, blank=True)
longitude = models.FloatField(null=True, blank=True)
def save(self, *args, **kwargs):
coordinates = geocode(self.address)[0]
if not self.latitude or not self.longitude or abs(self.latitude-coordinates['lat'])>5e-3 or abs(self.longitude-coordinates['long'])>5e-3:
self.latitude = coordinates['lat']
self.longitude = coordinates['long']
super(Housing, self).save(*args, **kwargs)
def __str__(self):
return self.address if self.address else self.id
@property
def last_roommates(self):
last_roommates = Roommates.objects.filter(housing=self).order_by('begin_date').last()
return last_roommates
class Roommates(Group):
name = models.CharField(verbose_name='Nom du groupe',
max_length=100)
begin_date = models.DateField("Date d'emménagement", default=date.today)
end_date = models.DateField("Date de sortie", null=True, blank=True)
housing = models.ForeignKey(
to=Housing, on_delete=models.CASCADE)
members = models.ManyToManyField(
to=Student, through='NamedMembershipRoommates', blank=True)
class Meta:
verbose_name = "coloc"
class NamedMembershipRoommates(NamedMembership):
group = models.ForeignKey(
to=Roommates, on_delete=models.CASCADE)
nickname = models.CharField(
max_length=100, verbose_name='Surnom', blank=True, null=True)
def __str__(self):
if self.nickname:
return f'{self.nickname} ({self.student.name})'
else:
return self.student.name
<|code_end|>
server/apps/roommates/serializers.py
<|code_start|>from rest_framework import serializers
from .models import Housing, NamedMembershipRoommates, Roommates
class HousingLastRoommatesSerializer(serializers.ModelSerializer):
'''Serializer for the Housing Model to display on the map,
with only the last roommates.'''
roommates = serializers.SerializerMethodField()
class Meta:
model = Housing
fields='__all__'
def get_roommates(self, obj):
roommates = Roommates.objects.filter(housing=obj).order_by('begin_date').last()
return RoommatesSerializer(roommates, many=False, context=self._context).data
class RoommatesMemberSerializer(serializers.ModelSerializer):
'''Serializer for a member of roommates'''
#student = StudentSerializer(read_only=True)
name = serializers.SerializerMethodField()
class Meta:
model = NamedMembershipRoommates
fields = ['nickname', 'name']
def get_name(self, obj):
return obj.student.name
class RoommatesSerializer(serializers.ModelSerializer):
'''Serializer for roommates'''
members = serializers.SerializerMethodField() #RoommatesMemberSerializer(read_only=True, many=True)
url = serializers.SerializerMethodField()
class Meta:
model = Roommates
fields = ['name', 'begin_date', 'end_date', 'members', 'url']
def get_members(self, obj):
members = NamedMembershipRoommates.objects.filter(group=obj)
return RoommatesMemberSerializer(members, many=True, context=self._context).data
def get_url(self, obj):
return obj.get_absolute_url
'''
class HousingSerializer(serializers.ModelSerializer):
edit_url = serializers.HyperlinkedIdentityField(
view_name='roommates:update', read_only=True, lookup_field='slug')
url = serializers.HyperlinkedIdentityField(
view_name='roommates:detail', read_only=True, lookup_field='slug')
roommates = serializers.SerializerMethodField()
name = serializers.SerializerMethodField()
class Meta:
model = Housing
fields = '__all__'
def get_roommates(self, obj):
roommates = Roommates.objects.filter(housing=obj)
return RoommatesGroupSerializer(roommates, many=True, context=self._context).data
def get_name(self, obj):
query = Roommates.objects.filter(housing=obj).order_by('begin_date').last()
return query.name if query else "Coloc sans nom"
class RoommatesMemberSerializer(serializers.ModelSerializer):
student = StudentSerializer(read_only=True)
edit_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-member', read_only=True)
class Meta:
model = NamedMembershipRoommates
fields = '__all__'
def create(self, validated_data):
return NamedMembershipRoommates.objects.create(
student=self.student,
group=validated_data['group']
)
class RoommatesGroupSerializer(serializers.ModelSerializer):
"""A serializer for the roommates group."""
members = serializers.SerializerMethodField()
edit_members_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-members', read_only=True)
edit_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-group-edit', read_only=True)
class Meta:
model = Roommates
fields = '__all__'
def get_members(self, obj):
members = NamedMembershipRoommates.objects.filter(group=obj.id)
return RoommatesMemberSerializer(members, many=True, context=self._context).data
def create(self, validated_data):
roommates = Roommates(
name=validated_data['name'],
housing=validated_data['housing'],
begin_date=validated_data['begin_date']
)
roommates.save()
for member in self.members:
NamedMembershipRoommates.objects.create(
student=Student.objects.get(id=member['student']),
group=roommates,
nickname=member['nickname']
)
return roommates
'''<|code_end|>
|
server/apps/roommates/api_views.py
<|code_start|>from rest_framework import generics, permissions, status
from rest_framework.response import Response
from rest_framework.views import APIView
# HousingSerializer, RoommatesGroupSerializer, RoommatesMemberSerializer
from .serializers import HousingLastRoommatesSerializer
from .models import Housing, NamedMembershipRoommates, Roommates
from apps.student.models import Student
from apps.utils.geocoding import geocode
from django.utils import timezone
from django.db.models import Q
class SearchGeocodingView(APIView):
"""A view to query the external Geocoding service."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request):
return Response(data=geocode(request.GET.get("search_string")))
class HousingView(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingLastRoommatesSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
now = timezone.now()
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | (Q(roommates__members=None))).distinct()
return query
class CheckAddressView(APIView):
"""An API view to wether wether a housing already exists at selected address.
Returns the pk if it does, None otherwise"""
permission_classes = [permissions.IsAuthenticated]
def post(self, request):
query = Housing.objects.filter(address=request.data.get("address"))
data = [{
'pk': housing.pk,
'name': f'{housing.address} - {housing.details} ({housing.current_roommates})'
} for housing in query]
return Response(data=data)
'''
class HousingView(generics.ListCreateAPIView):
serializer_class = HousingSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Housing.objects.all()
class HousingRoommates(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
now = timezone.now()
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | (Q(roommates__members=None))).distinct()
return query
class RoommatesGroupView(generics.ListCreateAPIView):
"""API View to get all the groups of roommates that lived in a house."""
serializer_class = RoommatesGroupSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Roommates.objects.filter(housing=self.kwargs['pk'])
def create(self, request, *args, **kwargs):
housing = generics.get_object_or_404(Housing, pk=self.kwargs['pk'])
copy = request.data.copy()
copy['housing'] = housing.pk
serializer = self.get_serializer(
data=copy)
# Due to the fact that the student field in the NamedMembershipRoommates Serializer
# has to be read_only, the student id is passed as an attribute of the serializer
# otherwise it would be cleaned out in the validated data.
serializer.members = [] if not request.data['add_me'] else [
{
'student': request.user.student.id,
'nickname': request.data['nickname'],
}
]
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class RoommatesMembersView(generics.ListCreateAPIView):
"""API View to list members of a roommates group."""
serializer_class = RoommatesMemberSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return NamedMembershipRoommates.objects.filter(roommates=self.kwargs['pk'])
def create(self, request, *args, **kwargs):
group = generics.get_object_or_404(
Roommates, id=self.kwargs['pk'])
copy = request.data.copy()
copy['group'] = group.id
student = generics.get_object_or_404(
Student, id=request.data['student'])
serializer = self.get_serializer(data=copy)
serializer.student = student
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
class RoommatesGroupEditView(generics.RetrieveUpdateDestroyAPIView):
"""API View to update or delete a roommates group."""
serializer_class = RoommatesGroupSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return Roommates.objects.filter(id=self.kwargs['pk'])
class RoommatesMemberView(generics.RetrieveUpdateDestroyAPIView):
"""API View to get a specific membership and update or delete it."""
serializer_class = RoommatesMemberSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
return NamedMembershipRoommates.objects.filter(id=self.kwargs['pk'])
'''
<|code_end|>
server/apps/roommates/models.py
<|code_start|>from django.db import models
from datetime import date
from apps.group.models import Group, NamedMembership
from apps.student.models import Student
from apps.utils.geocoding import geocode
from django.db.models import Q
from django.utils import timezone
class Housing(models.Model):
address = models.CharField(
max_length=250, verbose_name='Adresse')
details = models.CharField(
max_length=100, verbose_name='Complément d\'adresse', null=True, blank=True)
latitude = models.FloatField(null=True, blank=True)
longitude = models.FloatField(null=True, blank=True)
def save(self, *args, **kwargs):
coordinates = geocode(self.address)[0]
if not self.latitude or not self.longitude or abs(self.latitude-coordinates['lat']) > 5e-3 or abs(self.longitude-coordinates['long']) > 5e-3:
self.latitude = coordinates['lat']
self.longitude = coordinates['long']
super(Housing, self).save(*args, **kwargs)
def __str__(self):
return self.address if self.address else self.id
@property
def current_roommates(self):
now = timezone.now()
return Roommates.objects.filter(Q(housing=self) & (Q(Q(begin_date__lte=now) & (
Q(end_date__gte=now) | Q(end_date=None))) | (Q(members=None)))).order_by('begin_date').last()
class Roommates(Group):
name = models.CharField(verbose_name='Nom du groupe',
max_length=100)
begin_date = models.DateField("Date d'emménagement", default=date.today)
end_date = models.DateField("Date de sortie", null=True, blank=True)
housing = models.ForeignKey(
to=Housing, on_delete=models.CASCADE)
members = models.ManyToManyField(
to=Student, through='NamedMembershipRoommates', blank=True)
class Meta:
verbose_name = "coloc"
class NamedMembershipRoommates(NamedMembership):
group = models.ForeignKey(
to=Roommates, on_delete=models.CASCADE)
nickname = models.CharField(
max_length=100, verbose_name='Surnom', blank=True, null=True)
def __str__(self):
if self.nickname:
return f'{self.nickname} ({self.student.name})'
else:
return self.student.name
<|code_end|>
server/apps/roommates/serializers.py
<|code_start|>from rest_framework import serializers
from .models import Housing, NamedMembershipRoommates, Roommates
from django.db.models import Q
from django.utils import timezone
class HousingLastRoommatesSerializer(serializers.ModelSerializer):
'''Serializer for the Housing Model to display on the map,
with only the last roommates.'''
roommates = serializers.SerializerMethodField()
class Meta:
model = Housing
fields = '__all__'
def get_roommates(self, obj):
return RoommatesSerializer(obj.current_roommates, many=False, context=self._context).data
class RoommatesMemberSerializer(serializers.ModelSerializer):
'''Serializer for a member of roommates'''
#student = StudentSerializer(read_only=True)
name = serializers.SerializerMethodField()
class Meta:
model = NamedMembershipRoommates
fields = ['nickname', 'name']
def get_name(self, obj):
return obj.student.name
class RoommatesSerializer(serializers.ModelSerializer):
'''Serializer for roommates'''
# RoommatesMemberSerializer(read_only=True, many=True)
members = serializers.SerializerMethodField()
url = serializers.SerializerMethodField()
class Meta:
model = Roommates
fields = ['name', 'begin_date', 'end_date', 'members', 'url']
def get_members(self, obj):
members = NamedMembershipRoommates.objects.filter(group=obj)
return RoommatesMemberSerializer(members, many=True, context=self._context).data
def get_url(self, obj):
return obj.get_absolute_url
'''
class HousingSerializer(serializers.ModelSerializer):
edit_url = serializers.HyperlinkedIdentityField(
view_name='roommates:update', read_only=True, lookup_field='slug')
url = serializers.HyperlinkedIdentityField(
view_name='roommates:detail', read_only=True, lookup_field='slug')
roommates = serializers.SerializerMethodField()
name = serializers.SerializerMethodField()
class Meta:
model = Housing
fields = '__all__'
def get_roommates(self, obj):
roommates = Roommates.objects.filter(housing=obj)
return RoommatesGroupSerializer(roommates, many=True, context=self._context).data
def get_name(self, obj):
query = Roommates.objects.filter(housing=obj).order_by('begin_date').last()
return query.name if query else "Coloc sans nom"
class RoommatesMemberSerializer(serializers.ModelSerializer):
student = StudentSerializer(read_only=True)
edit_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-member', read_only=True)
class Meta:
model = NamedMembershipRoommates
fields = '__all__'
def create(self, validated_data):
return NamedMembershipRoommates.objects.create(
student=self.student,
group=validated_data['group']
)
class RoommatesGroupSerializer(serializers.ModelSerializer):
"""A serializer for the roommates group."""
members = serializers.SerializerMethodField()
edit_members_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-members', read_only=True)
edit_api_url = serializers.HyperlinkedIdentityField(
view_name='roommates_api:roommates-group-edit', read_only=True)
class Meta:
model = Roommates
fields = '__all__'
def get_members(self, obj):
members = NamedMembershipRoommates.objects.filter(group=obj.id)
return RoommatesMemberSerializer(members, many=True, context=self._context).data
def create(self, validated_data):
roommates = Roommates(
name=validated_data['name'],
housing=validated_data['housing'],
begin_date=validated_data['begin_date']
)
roommates.save()
for member in self.members:
NamedMembershipRoommates.objects.create(
student=Student.objects.get(id=member['student']),
group=roommates,
nickname=member['nickname']
)
return roommates
'''
<|code_end|>
|
Colocathlon
Préparation du support de fonctionnalités pour le colocathlon, à la demande du BDE. Fonctionnalités demandées :
- [x] Possibilité pour chaque coloc de renseigner ses horaires d'ouvertures et activités proposées, et si elles participent ou non
- [x] Affichage des infos ci-dessous pour tout le monde sur la page de la coloc
- [x] Possibilité pour n'importe quel utilisateur connecté de s'inscrire à une et une seule coloc, sur le principe du shotgun
- [x] Pour les membres de la coloc, voir les utilisateurs inscrits
- [x] Activer un mode "Colocathlon" sur la carte pour afficher uniquement les colocs participantes
- [x] En mode colocathlon, afficher sur la carte les activités et heures proposées au lieu des descriptions et membres dans les infobulles
|
server/apps/group/models.py
<|code_start|>from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
from django.urls.base import reverse
from django.template.loader import render_to_string
from django.utils import timezone
from django_ckeditor_5.fields import CKEditor5Field
from apps.student.models import Student
from apps.utils.upload import PathAndRename
from apps.utils.compress import compressModelImage
from apps.utils.slug import get_object_from_full_slug, get_tuple_from_full_slug, SlugModel
from django.conf import settings
from discord_webhook import DiscordWebhook, DiscordEmbed
import logging
logger = logging.getLogger(__name__)
path_and_rename_group = PathAndRename("groups/logo")
path_and_rename_group_banniere = PathAndRename("groups/banniere")
class Group(models.Model, SlugModel):
'''Modèle abstrait servant de modèle pour tous les types de Groupes.'''
# Nom du groupe
name = models.CharField(verbose_name='Nom du groupe',
unique=True, max_length=100)
alt_name = models.CharField(
verbose_name='Nom alternatif', max_length=100, null=True, blank=True)
# présentation
logo = models.ImageField(
verbose_name='Logo du groupe', blank=True, null=True,
upload_to=path_and_rename_group,
help_text="Votre logo sera affiché au format 306x306 pixels.")
banniere = models.ImageField(
verbose_name='Bannière', blank=True, null=True,
upload_to=path_and_rename_group_banniere,
help_text="Votre bannière sera affichée au format 1320x492 pixels.")
summary = models.CharField('Résumé', max_length=500, null=True, blank=True)
description = CKEditor5Field(
verbose_name='Description du groupe', blank=True)
video1 = models.URLField(
'Lien vidéo 1', max_length=200, null=True, blank=True)
video2 = models.URLField(
'Lien vidéo 2', max_length=200, null=True, blank=True)
# paramètres techniques
members = models.ManyToManyField(
Student, verbose_name='Membres du groupe', related_name='%(class)s_members', through='NamedMembership')
slug = models.SlugField(max_length=40, unique=True, blank=True)
modified_date = models.DateTimeField(auto_now=True)
class Meta:
abstract = True
def __str__(self):
return self.name
def is_admin(self, user: User) -> bool:
"""Indicates if a user is admin."""
if user.is_anonymous or not user.is_authenticated or not hasattr(user, 'student'):
return False
student = Student.objects.filter(user=user).first()
if user.is_superuser or user.is_staff:
return True
if self.is_member(user):
members_list = self.members.through.objects.filter(group=self)
my_member = members_list.filter(student=student).first()
return my_member.admin
return False
def is_member(self, user: User) -> bool:
"""Indicates if a user is member."""
if user.is_anonymous or not user.is_authenticated or not hasattr(user, 'student'):
return False
return user.student in self.members.all()
def save(self, *args, **kwargs):
# cration du slug si non-existant ou corrompu
self.set_slug(self.name, 40)
# compression des images
self.logo = compressModelImage(
self, 'logo', size=(500, 500), contains=True)
self.banniere = compressModelImage(
self, 'banniere', size=(1320, 492), contains=False)
# enregistrement
super(Group, self).save(*args, **kwargs)
@property
def app(self):
return self._meta.app_label
@property
def full_slug(self):
return f'{self.app}--{self.slug}'
# Don't make this a property, Django expects it to be a method.
# Making it a property can cause a 500 error (see issue #553).
def get_absolute_url(self):
return reverse(self.app+':detail', kwargs={'slug': self.slug})
@property
def modelName(self):
'''Plural Model name, used in templates'''
return self.__class__._meta.verbose_name_plural
class NamedMembership(models.Model):
admin = models.BooleanField(default=False)
student = models.ForeignKey(to=Student, on_delete=models.CASCADE)
group = models.ForeignKey(to=Group, on_delete=models.CASCADE)
class Meta:
abstract = True
def __str__(self):
return self.student.__str__()
class AdminRightsRequest(models.Model):
"""A model to request admin rights on a group."""
group = models.SlugField(verbose_name="Groupe demandé.")
student = models.ForeignKey(to=Student, on_delete=models.CASCADE)
date = models.DateField(
verbose_name="Date de la requête", default=timezone.now)
reason = models.CharField(
max_length=100, verbose_name="Raison de la demande", blank=True)
domain = models.CharField(max_length=64)
def save(self, domain: str, *args, **kwargs):
self.date = timezone.now()
self.domain = domain
super(AdminRightsRequest, self).save()
group = get_object_from_full_slug(self.group)
try:
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'{self.student} demande à devenir admin de {group}',
description=self.reason,
color=242424)
embed.add_embed_field(
name='Accepter', value=f"[Accepter]({self.accept_url})", inline=True)
embed.add_embed_field(
name='Refuser', value=f"[Refuser]({self.deny_url})", inline=True)
if(self.student.picture):
embed.thumbnail = {"url": self.student.picture.url}
webhook.add_embed(embed)
webhook.execute()
except Exception as e:
logger.error(e)
super(AdminRightsRequest, self).save()
@ property
def accept_url(self):
app, slug = get_tuple_from_full_slug(self.group)
return f"http://{self.domain}{reverse(app+':accept-admin-req', kwargs={'slug': slug,'id': self.id})}"
@ property
def deny_url(self):
app, slug = get_tuple_from_full_slug(self.group)
return f"http://{self.domain}{reverse(app+':deny-admin-req', kwargs={'slug': slug, 'id': self.id})}"
def accept(self):
group = get_object_from_full_slug(self.group)
if group.is_member(self.student.user):
membership = group.members.through.objects.get(
student=self.student.id, group=group)
membership.admin = True
membership.save()
else:
group.members.through.objects.create(
student=self.student,
group=group,
admin=True
)
mail = render_to_string('group/mail/new_admin.html', {
'group': group,
'user': self.student.user
})
self.student.user.email_user(f'Vous êtes admin de {group}', mail,
'[email protected]', html_message=mail)
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'La demande de {self.student} pour rejoindre {group} a été acceptée.',
description="",
color=00000)
webhook.add_embed(embed)
webhook.execute()
self.delete()
def deny(self):
group = get_object_from_full_slug(self.group)
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'La demande de {self.student} pour rejoindre {group} a été refusée.',
description="",
color=00000)
webhook.add_embed(embed)
webhook.execute()
self.delete()
# FIXME Broken since the move of admins inside of members, nice to fix
# @receiver(m2m_changed, sender=Group.members.through)
# def admins_changed(sender, instance, action, pk_set, reverse, model, **kwargs):
# if isinstance(instance, Group):
# # FIXME temporary fix because this signal shotguns m2m_changed which other can't
# # use. To avoid this we check the instance before to make sure it's a group.
# if action == "post_add":
# for pk in pk_set:
# user = User.objects.get(pk=pk)
# mail = render_to_string('group/mail/new_admin.html', {
# 'group': instance,
# 'user': user
# })
# user.email_user(f'Vous êtes admin de {instance}', mail,
# '[email protected]', html_message=mail)
# elif action == "post_remove":
# for pk in pk_set:
# user = User.objects.get(pk=pk)
# mail = render_to_string('group/mail/remove_admin.html', {
# 'group': instance,
# 'user': user
# })
# user.email_user(
# f'Vous n\'êtes plus membre de {instance}', mail, '[email protected]', html_message=mail)
<|code_end|>
server/apps/roommates/api_urls.py
<|code_start|>from django.urls import path
from .api_views import *
app_name = 'roommates_api'
urlpatterns = [
path('geocoding/', SearchGeocodingView.as_view(), name='geocoding'),
path('housing', HousingView.as_view(), name='housing'),
path('housing/check', CheckAddressView.as_view(), name='address-check'),
]
<|code_end|>
server/apps/roommates/api_views.py
<|code_start|>from rest_framework import generics, permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from .serializers import HousingLastRoommatesSerializer
from .models import Housing
from apps.utils.geocoding import geocode
from django.utils import timezone
from django.db.models import Q
class SearchGeocodingView(APIView):
"""A view to query the external Geocoding service."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request):
return Response(data=geocode(request.GET.get("search_string")))
class HousingView(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingLastRoommatesSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
colocathlonParticipants = int(self.request.GET.get(
'colocathlonParticipants'))
now = timezone.now()
if colocathlonParticipants == 1:
query = Housing.objects.filter((
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | Q(roommates__members=None)) & Q(roommates__colocathlon_agree=True)).distinct()
return query
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | Q(roommates__members=None)).distinct()
return query
class CheckAddressView(APIView):
"""An API view to check whether a housing already exists at the selected address.
Returns the pk if it does, None otherwise"""
permission_classes = [permissions.IsAuthenticated]
def post(self, request):
query = Housing.objects.filter(address=request.data.get("address"))
data = [{
'pk': housing.pk,
'name': f'{housing.address} - {housing.details} ({housing.current_roommates})'
} for housing in query]
return Response(data=data)
<|code_end|>
|
server/apps/group/models.py
<|code_start|>from django.db import models
from django.contrib.auth.models import User
from django.utils.text import slugify
from django.urls.base import reverse
from django.template.loader import render_to_string
from django.utils import timezone
from django_ckeditor_5.fields import CKEditor5Field
from apps.student.models import Student
from apps.utils.upload import PathAndRename
from apps.utils.compress import compressModelImage
from apps.utils.slug import get_object_from_full_slug, get_tuple_from_full_slug, SlugModel
from django.conf import settings
from discord_webhook import DiscordWebhook, DiscordEmbed
import logging
logger = logging.getLogger(__name__)
path_and_rename_group = PathAndRename("groups/logo")
path_and_rename_group_banniere = PathAndRename("groups/banniere")
class Group(models.Model, SlugModel):
'''Modèle abstrait servant de modèle pour tous les types de Groupes.'''
# Nom du groupe
name = models.CharField(verbose_name='Nom du groupe',
unique=True, max_length=100)
alt_name = models.CharField(
verbose_name='Nom alternatif', max_length=100, null=True, blank=True)
# présentation
logo = models.ImageField(
verbose_name='Logo du groupe', blank=True, null=True,
upload_to=path_and_rename_group,
help_text="Votre logo sera affiché au format 306x306 pixels.")
banniere = models.ImageField(
verbose_name='Bannière', blank=True, null=True,
upload_to=path_and_rename_group_banniere,
help_text="Votre bannière sera affichée au format 1320x492 pixels.")
summary = models.CharField('Résumé', max_length=500, null=True, blank=True)
description = CKEditor5Field(
verbose_name='Description du groupe', blank=True)
video1 = models.URLField(
'Lien vidéo 1', max_length=200, null=True, blank=True)
video2 = models.URLField(
'Lien vidéo 2', max_length=200, null=True, blank=True)
# paramètres techniques
members = models.ManyToManyField(
Student, verbose_name='Membres du groupe', related_name='%(class)s_members', through='NamedMembership')
slug = models.SlugField(max_length=40, unique=True, blank=True)
modified_date = models.DateTimeField(auto_now=True)
class Meta:
abstract = True
def __str__(self):
return self.name
def is_admin(self, user: User) -> bool:
"""Indicates if a user is admin."""
if user.is_anonymous or not user.is_authenticated or not hasattr(user, 'student'):
return False
student = Student.objects.filter(user=user).first()
if user.is_superuser:
return True
if self.is_member(user):
members_list = self.members.through.objects.filter(group=self)
my_member = members_list.filter(student=student).first()
return my_member.admin
return False
def is_member(self, user: User) -> bool:
"""Indicates if a user is member."""
if user.is_anonymous or not user.is_authenticated or not hasattr(user, 'student'):
return False
return user.student in self.members.all()
def save(self, *args, **kwargs):
# cration du slug si non-existant ou corrompu
self.set_slug(self.name, 40)
# compression des images
self.logo = compressModelImage(
self, 'logo', size=(500, 500), contains=True)
self.banniere = compressModelImage(
self, 'banniere', size=(1320, 492), contains=False)
# enregistrement
super(Group, self).save(*args, **kwargs)
@property
def app(self):
return self._meta.app_label
@property
def full_slug(self):
return f'{self.app}--{self.slug}'
# Don't make this a property, Django expects it to be a method.
# Making it a property can cause a 500 error (see issue #553).
def get_absolute_url(self):
return reverse(self.app+':detail', kwargs={'slug': self.slug})
@property
def modelName(self):
'''Plural Model name, used in templates'''
return self.__class__._meta.verbose_name_plural
class NamedMembership(models.Model):
admin = models.BooleanField(default=False)
student = models.ForeignKey(to=Student, on_delete=models.CASCADE)
group = models.ForeignKey(to=Group, on_delete=models.CASCADE)
class Meta:
abstract = True
def __str__(self):
return self.student.__str__()
class AdminRightsRequest(models.Model):
"""A model to request admin rights on a group."""
group = models.SlugField(verbose_name="Groupe demandé.")
student = models.ForeignKey(to=Student, on_delete=models.CASCADE)
date = models.DateField(
verbose_name="Date de la requête", default=timezone.now)
reason = models.CharField(
max_length=100, verbose_name="Raison de la demande", blank=True)
domain = models.CharField(max_length=64)
def save(self, domain: str, *args, **kwargs):
self.date = timezone.now()
self.domain = domain
super(AdminRightsRequest, self).save()
group = get_object_from_full_slug(self.group)
try:
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'{self.student} demande à devenir admin de {group}',
description=self.reason,
color=242424)
embed.add_embed_field(
name='Accepter', value=f"[Accepter]({self.accept_url})", inline=True)
embed.add_embed_field(
name='Refuser', value=f"[Refuser]({self.deny_url})", inline=True)
if(self.student.picture):
embed.thumbnail = {"url": self.student.picture.url}
webhook.add_embed(embed)
webhook.execute()
except Exception as e:
logger.error(e)
super(AdminRightsRequest, self).save()
@ property
def accept_url(self):
app, slug = get_tuple_from_full_slug(self.group)
return f"http://{self.domain}{reverse(app+':accept-admin-req', kwargs={'slug': slug,'id': self.id})}"
@ property
def deny_url(self):
app, slug = get_tuple_from_full_slug(self.group)
return f"http://{self.domain}{reverse(app+':deny-admin-req', kwargs={'slug': slug, 'id': self.id})}"
def accept(self):
group = get_object_from_full_slug(self.group)
if group.is_member(self.student.user):
membership = group.members.through.objects.get(
student=self.student.id, group=group)
membership.admin = True
membership.save()
else:
group.members.through.objects.create(
student=self.student,
group=group,
admin=True
)
mail = render_to_string('group/mail/new_admin.html', {
'group': group,
'user': self.student.user
})
self.student.user.email_user(f'Vous êtes admin de {group}', mail,
'[email protected]', html_message=mail)
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'La demande de {self.student} pour rejoindre {group} a été acceptée.',
description="",
color=00000)
webhook.add_embed(embed)
webhook.execute()
self.delete()
def deny(self):
group = get_object_from_full_slug(self.group)
webhook = DiscordWebhook(
url=settings.DISCORD_ADMIN_MODERATION_WEBHOOK)
embed = DiscordEmbed(title=f'La demande de {self.student} pour rejoindre {group} a été refusée.',
description="",
color=00000)
webhook.add_embed(embed)
webhook.execute()
self.delete()
# FIXME Broken since the move of admins inside of members, nice to fix
# @receiver(m2m_changed, sender=Group.members.through)
# def admins_changed(sender, instance, action, pk_set, reverse, model, **kwargs):
# if isinstance(instance, Group):
# # FIXME temporary fix because this signal shotguns m2m_changed which other can't
# # use. To avoid this we check the instance before to make sure it's a group.
# if action == "post_add":
# for pk in pk_set:
# user = User.objects.get(pk=pk)
# mail = render_to_string('group/mail/new_admin.html', {
# 'group': instance,
# 'user': user
# })
# user.email_user(f'Vous êtes admin de {instance}', mail,
# '[email protected]', html_message=mail)
# elif action == "post_remove":
# for pk in pk_set:
# user = User.objects.get(pk=pk)
# mail = render_to_string('group/mail/remove_admin.html', {
# 'group': instance,
# 'user': user
# })
# user.email_user(
# f'Vous n\'êtes plus membre de {instance}', mail, '[email protected]', html_message=mail)
<|code_end|>
server/apps/roommates/api_urls.py
<|code_start|>from django.urls import path
from .api_views import *
app_name = 'roommates_api'
urlpatterns = [
path('geocoding/', SearchGeocodingView.as_view(), name='geocoding'),
path('housing', HousingView.as_view(), name='housing'),
path('housing/check', CheckAddressView.as_view(), name='address-check'),
path('roommates-details', RoommatesDetails.as_view(), name="roommates-details")
]
<|code_end|>
server/apps/roommates/api_views.py
<|code_start|>from django.http.response import HttpResponse
from rest_framework import generics, permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from .serializers import HousingLastRoommatesSerializer, RoommatesSerializer
from .models import Housing, Roommates
from apps.utils.geocoding import geocode
from django.utils import timezone
from django.db.models import Q
class SearchGeocodingView(APIView):
"""A view to query the external Geocoding service."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request):
return Response(data=geocode(request.GET.get("search_string")))
class HousingView(generics.ListCreateAPIView):
"""API View to get all the housing and their current roommates"""
serializer_class = HousingLastRoommatesSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
colocathlonParticipants = int(self.request.GET.get(
'colocathlonParticipants'))
now = timezone.now()
if colocathlonParticipants == 1:
query = Housing.objects.filter((
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | Q(roommates__members=None)) & Q(roommates__colocathlon_agree=True)).distinct()
return query
query = Housing.objects.filter(
Q(Q(roommates__begin_date__lte=now) & (Q(roommates__end_date__gte=now) | Q(roommates__end_date=None))) | Q(roommates__members=None)).distinct()
return query
class CheckAddressView(APIView):
"""An API view to check whether a housing already exists at the selected address.
Returns the pk if it does, None otherwise"""
permission_classes = [permissions.IsAuthenticated]
def post(self, request):
query = Housing.objects.filter(address=request.data.get("address"))
data = [{
'pk': housing.pk,
'name': f'{housing.address} - {housing.details} ({housing.current_roommates})'
} for housing in query]
return Response(data=data)
class RoommatesDetails(APIView):
"""An API view to return the details of a roommates instance"""
serializer_class = RoommatesSerializer
permission_classes = [permissions.IsAuthenticated]
def get(self, request):
roommatesSlug = self.request.GET.get(
'slug')
roommates = [generics.get_object_or_404(Roommates, slug=roommatesSlug)]
serializer = self.serializer_class(roommates, many=True)
return Response(serializer.data)
def post(self, request):
roommates = generics.get_object_or_404(
Roommates, slug=request.data.get("slug"))
if not roommates.colocathlon_agree:
return Response(status=403)
addOrDelete = int(request.data.get("addOrDelete"))
# addOrDelete == 1 -> Delete user
# addOrDelete == 0 -> Add user
if addOrDelete == 0:
if roommates.colocathlon_quota > roommates.colocathlon_participants.count():
roommates.colocathlon_participants.add(request.user.student)
return Response(status=200)
return Response(status=403)
roommates.colocathlon_participants.remove(request.user.student)
return Response(status=200)
<|code_end|>
|
Colocathlon
Préparation du support de fonctionnalités pour le colocathlon, à la demande du BDE. Fonctionnalités demandées :
- [x] Possibilité pour chaque coloc de renseigner ses horaires d'ouvertures et activités proposées, et si elles participent ou non
- [x] Affichage des infos ci-dessous pour tout le monde sur la page de la coloc
- [x] Possibilité pour n'importe quel utilisateur connecté de s'inscrire à une et une seule coloc, sur le principe du shotgun
- [x] Pour les membres de la coloc, voir les utilisateurs inscrits
- [x] Activer un mode "Colocathlon" sur la carte pour afficher uniquement les colocs participantes
- [x] En mode colocathlon, afficher sur la carte les activités et heures proposées au lieu des descriptions et membres dans les infobulles
|
server/apps/club/api_views.py
<|code_start|>from django.http.response import HttpResponse
from rest_framework import generics, permissions
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from django.db.models import Q
from django.utils import timezone
from django.utils.dateparse import parse_date
from rest_framework.views import APIView
from .models import Club, NamedMembershipClub
from apps.student.models import Student
from .serializers import *
class ListMyClubAPIView(generics.ListAPIView):
"""List all the clubs of a student."""
serializer_class = ClubSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
if self.request.user.is_authenticated:
allMembersClub = Club.objects.filter(
members__user=self.request.user)
return allMembersClub
class ListClubMembersAPIView(APIView):
"""API endpoint to interact with the members of a club."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request, format=None):
clubSlug = request.query_params.get('slug')
club = get_object_or_404(Club, slug=clubSlug)
date_end = timezone.make_aware(timezone.now().today())
namedMemberships = club.members.through.objects.filter(
Q(group=club) & (Q(date_end__isnull=True) | Q(date_end__gt=date_end))
).order_by('student__user__first_name')
serializer = ClubMemberSerializer(namedMemberships, many=True)
return Response(data=serializer.data)
def post(self, request, *args, **kwargs):
# Check if club's admin
user = self.request.user
student = Student.objects.get(user=user)
clubSlug = request.query_params.get('slug')
club = get_object_or_404(Club, slug=clubSlug)
toCheckIfAdmin = get_object_or_404(
NamedMembershipClub, group=club, student=student)
if not (toCheckIfAdmin.admin or user.is_staff):
return HttpResponse(status=403)
editMode = request.data.get("editMode")
# editMode == 1 -> Edit the order of the members
# editMode == 2 -> Edit a member
# editMode == 3 -> Delete a member
if editMode == 1:
newOrderedMembers = request.data.get("orderedMembers")
for member in newOrderedMembers:
NamedMembershipClub.objects.filter(
id=member.get("id")).update(order=member.get("order"))
return HttpResponse(status=200)
elif editMode == 2:
id = request.data.get("id")
role = request.data.get("role")
beginDate = parse_date(request.data.get("beginDate")) if request.data.get(
"beginDate") is not None else None
endDate = parse_date(request.data.get("endDate")) if request.data.get(
"endDate") is not None else None
admin = request.data.get("admin")
NamedMembershipClub.objects.filter(
id=id).update(function=role, admin=admin, date_begin=beginDate, date_end=endDate)
return HttpResponse(status=200)
elif editMode == 3:
id = request.data.get("id")
NamedMembershipClub.objects.get(id=id).delete()
return HttpResponse(status=200)
<|code_end|>
server/apps/club/models.py
<|code_start|>from django.db import models
from django.db.models import F
from django.utils import timezone
from django.core.cache import cache
from django.core.cache.utils import make_template_fragment_key
from apps.group.models import Group, NamedMembership
from apps.student.models import Student
class Club(Group):
members = models.ManyToManyField(Student, through='NamedMembershipClub')
bdx_type = models.ForeignKey(
'BDX', on_delete=models.SET_NULL, verbose_name='Type de club BDX', null=True, blank=True)
email = models.EmailField("Email de l'asso", max_length=50, null=True, blank=True)
meeting_place = models.CharField("Local / Lieu de réunion", max_length=50, null=True, blank=True)
meeting_hour = models.CharField("Heure et jour de réunion périodique", max_length=50, null=True, blank=True)
class Meta:
ordering = [F('bdx_type').asc(nulls_first=True), 'name']
verbose_name = "club/asso"
verbose_name_plural = "clubs & assos"
def is_admin(self, user) -> bool:
is_admin = super(Club, self).is_admin(user)
if not is_admin and self.bdx_type:
return self.bdx_type.is_admin(user)
else:
return is_admin
def save(self, *args, **kwargs):
# mise à jour du cache de la liste des clubs
key = make_template_fragment_key('club_list')
cache.delete(key)
# enregistrement
super().save(*args, **kwargs)
class BDX(Club):
'''Groupe représentant un BDX.'''
order = models.IntegerField(default=0)
class Meta:
ordering = ['order']
verbose_name_plural = "BDX"
class NamedMembershipClub(NamedMembership):
group = models.ForeignKey(Club, on_delete=models.CASCADE)
function = models.CharField(
verbose_name='Rôle (facultatif)', max_length=200, blank=True)
date_begin = models.DateField(verbose_name='Date de début', default=timezone.now().today)
date_end = models.DateField(verbose_name='Date de fin (facultatif)', blank=True, null=True)
order = models.IntegerField(verbose_name='Hiérarchie', default=0)
@property
def year(self, **kwargs):
'''Renvoie l'année scolaire où l'étudiant est devenu membre.
On renvoie seulement la 2eme année de l'année scolaire.'''
y = self.date_begin.year
m = self.date_begin.month
if m >= 8:
return y + 1
else:
return y<|code_end|>
server/apps/student/api_urls.py
<|code_start|>from django.conf.urls import url
from django.urls import path
from .api_views import *
app_name = 'student'
urlpatterns = [
path('<slug:student_id>/courses/',
StudentCoursesView.as_view(), name='courses'),
path('<slug:student_id>/courses/<slug:pk>',
StudentEditNamedMembershipCourse.as_view(), name='unfollow-course'),
path('', StudentList.as_view(), name='list')
]
<|code_end|>
|
server/apps/club/api_views.py
<|code_start|>from django.http.response import HttpResponse
from rest_framework import generics, permissions
from rest_framework.response import Response
from django.shortcuts import get_object_or_404
from django.db.models import Q
from django.utils import timezone
from django.utils.dateparse import parse_date
from rest_framework.views import APIView
from .models import Club, NamedMembershipClub
from apps.student.models import Student
from .serializers import *
class ListMyClubAPIView(generics.ListAPIView):
"""List all the clubs of a student."""
serializer_class = ClubSerializer
permission_classes = [permissions.IsAuthenticated]
def get_queryset(self):
if self.request.user.is_authenticated:
allMembersClub = Club.objects.filter(
members__user=self.request.user)
return allMembersClub
class ListClubMembersAPIView(APIView):
"""API endpoint to interact with the members of a club."""
permission_classes = [permissions.IsAuthenticated]
def get(self, request, format=None):
clubSlug = request.query_params.get('slug')
club = get_object_or_404(Club, slug=clubSlug)
date_end = timezone.make_aware(timezone.now().today())
namedMemberships = club.members.through.objects.filter(
Q(group=club) & (Q(date_end__isnull=True) | Q(date_end__gt=date_end))
).order_by('student__user__first_name')
serializer = ClubMemberSerializer(namedMemberships, many=True)
return Response(data=serializer.data)
def post(self, request, *args, **kwargs):
# Check if club's admin
user = self.request.user
student = Student.objects.get(user=user)
clubSlug = request.query_params.get('slug')
club = get_object_or_404(Club, slug=clubSlug)
toCheckIfAdmin = get_object_or_404(
NamedMembershipClub, group=club, student=student)
if not (toCheckIfAdmin.admin or user.is_staff):
return HttpResponse(status=403)
editMode = request.data.get("editMode")
# editMode == 1 -> Edit the order of the members
# editMode == 2 -> Edit a member
# editMode == 3 -> Delete a member
# editMode == 4 -> Add a member
if editMode == 1:
newOrderedMembers = request.data.get("orderedMembers")
for member in newOrderedMembers:
NamedMembershipClub.objects.filter(
id=member.get("id")).update(order=member.get("order"))
return HttpResponse(status=200)
elif editMode == 2:
id = request.data.get("id")
role = request.data.get("role")
beginDate = parse_date(request.data.get("beginDate")) if request.data.get(
"beginDate") is not None else None
endDate = parse_date(request.data.get("endDate")) if request.data.get(
"endDate") is not None else None
admin = request.data.get("admin")
NamedMembershipClub.objects.filter(
id=id).update(function=role, admin=admin, date_begin=beginDate, date_end=endDate)
return HttpResponse(status=200)
elif editMode == 3:
id = request.data.get("id")
NamedMembershipClub.objects.get(id=id).delete()
return HttpResponse(status=200)
elif editMode == 4:
studentIDToAdd = request.data.get("id")
studentToAdd = Student.objects.get(id=studentIDToAdd)
# Check if student already exists
if NamedMembershipClub.objects.filter(
student=studentToAdd, group=club).exists():
return HttpResponse(status=403)
admin = request.data.get("admin")
function = request.data.get("function")
beginDate = parse_date(request.data.get("date_begin")) if request.data.get(
"beginDate") is not None else None
endDate = parse_date(request.data.get("date_end")) if request.data.get(
"endDate") is not None else None
# Check if dates are valid
if beginDate is not None and endDate is not None and beginDate > endDate:
return HttpResponse(status=500)
if beginDate is not None:
NamedMembershipClub.objects.create(
group=club,
student=studentToAdd,
admin=admin,
function=function,
date_begin=beginDate,
date_end=endDate).save()
else:
NamedMembershipClub.objects.create(
group=club,
student=studentToAdd,
admin=admin,
function=function).save()
return HttpResponse(status=200)
<|code_end|>
server/apps/club/models.py
<|code_start|>from django.db import models
from django.db.models import F
from django.utils import timezone
from django.core.cache import cache
from django.core.cache.utils import make_template_fragment_key
from apps.group.models import Group, NamedMembership
from apps.student.models import Student
class Club(Group):
members = models.ManyToManyField(Student, through='NamedMembershipClub')
bdx_type = models.ForeignKey(
'BDX', on_delete=models.SET_NULL, verbose_name='Type de club BDX', null=True, blank=True)
email = models.EmailField(
"Email de l'asso", max_length=50, null=True, blank=True)
meeting_place = models.CharField(
"Local / Lieu de réunion", max_length=50, null=True, blank=True)
meeting_hour = models.CharField(
"Heure et jour de réunion périodique", max_length=50, null=True, blank=True)
class Meta:
ordering = [F('bdx_type').asc(nulls_first=True), 'name']
verbose_name = "club/asso"
verbose_name_plural = "clubs & assos"
def is_admin(self, user) -> bool:
is_admin = super(Club, self).is_admin(user)
if not is_admin and self.bdx_type:
return self.bdx_type.is_admin(user)
else:
return is_admin
def save(self, *args, **kwargs):
# mise à jour du cache de la liste des clubs
key = make_template_fragment_key('club_list')
cache.delete(key)
# enregistrement
super().save(*args, **kwargs)
class BDX(Club):
'''Groupe représentant un BDX.'''
order = models.IntegerField(default=0)
class Meta:
ordering = ['order']
verbose_name_plural = "BDX"
class NamedMembershipClub(NamedMembership):
group = models.ForeignKey(Club, on_delete=models.CASCADE)
function = models.CharField(
verbose_name='Rôle (facultatif)', max_length=200, blank=True)
date_begin = models.DateField(
verbose_name='Date de début', default=timezone.now().today)
date_end = models.DateField(
verbose_name='Date de fin (facultatif)', blank=True, null=True)
order = models.IntegerField(verbose_name='Hiérarchie', default=0)
@property
def year(self, **kwargs):
'''Renvoie l'année scolaire où l'étudiant est devenu membre.
On renvoie seulement la 2eme année de l'année scolaire.'''
y = self.date_begin.year
m = self.date_begin.month
if m >= 8:
return y + 1
else:
return y
def get_or_create(self, **kwargs):
defaults = kwargs.pop('defaults', {}) # popping defaults from values
for key, value in kwargs.items():
if value == None:
kwargs[key] = defaults.get(key)
return super(NamedMembershipClub, self).get_or_create(**kwargs)
<|code_end|>
server/apps/student/api_urls.py
<|code_start|>from django.urls import path
from .api_views import *
app_name = 'student'
urlpatterns = [
path('<slug:student_id>/courses/',
StudentCoursesView.as_view(), name='courses'),
path('<slug:student_id>/courses/<slug:pk>',
StudentEditNamedMembershipCourse.as_view(), name='unfollow-course'),
path('', StudentList.as_view(), name='list')
]
<|code_end|>
|
Add vanilla GRU
We want to a simple vanilla GRU for time series forecasting maybe with the probabilistic component as well.
|
flood_forecast/basic/gru_vanilla.py
<|code_start|><|code_end|>
flood_forecast/model_dict_function.py
<|code_start|>from flood_forecast.transformer_xl.multi_head_base import MultiAttnHeadSimple
from flood_forecast.transformer_xl.transformer_basic import SimpleTransformer, CustomTransformerDecoder
from flood_forecast.transformer_xl.informer import Informer
from flood_forecast.transformer_xl.transformer_xl import TransformerXL
from flood_forecast.transformer_xl.dummy_torch import DummyTorchModel
from flood_forecast.basic.linear_regression import SimpleLinearModel
from flood_forecast.basic.lstm_vanilla import LSTMForecast
from flood_forecast.custom.custom_opt import BertAdam
from torch.optim import Adam, SGD
from torch.nn import MSELoss, SmoothL1Loss, PoissonNLLLoss, L1Loss, CrossEntropyLoss, BCELoss, BCEWithLogitsLoss
from flood_forecast.basic.linear_regression import simple_decode
from flood_forecast.transformer_xl.transformer_basic import greedy_decode
from flood_forecast.custom.focal_loss import FocalLoss
from flood_forecast.da_rnn.model import DARNN
from flood_forecast.custom.custom_opt import (RMSELoss, MAPELoss, PenalizedMSELoss, NegativeLogLikelihood, MASELoss,
GaussianLoss)
from flood_forecast.transformer_xl.transformer_bottleneck import DecoderTransformer
from flood_forecast.custom.dilate_loss import DilateLoss
from flood_forecast.meta_models.basic_ae import AE
from flood_forecast.transformer_xl.dsanet import DSANet
"""
Utility dictionaries to map a string to a class
"""
pytorch_model_dict = {
"MultiAttnHeadSimple": MultiAttnHeadSimple,
"SimpleTransformer": SimpleTransformer,
"TransformerXL": TransformerXL,
"DummyTorchModel": DummyTorchModel,
"LSTM": LSTMForecast,
"SimpleLinearModel": SimpleLinearModel,
"CustomTransformerDecoder": CustomTransformerDecoder,
"DARNN": DARNN,
"DecoderTransformer": DecoderTransformer,
"BasicAE": AE,
"Informer": Informer,
"DSANet": DSANet
}
pytorch_criterion_dict = {
"GaussianLoss": GaussianLoss,
"MASELoss": MASELoss,
"MSE": MSELoss,
"SmoothL1Loss": SmoothL1Loss,
"PoissonNLLLoss": PoissonNLLLoss,
"RMSE": RMSELoss,
"MAPE": MAPELoss,
"DilateLoss": DilateLoss,
"L1": L1Loss,
"PenalizedMSELoss": PenalizedMSELoss,
"CrossEntropyLoss": CrossEntropyLoss,
"NegativeLogLikelihood": NegativeLogLikelihood,
"BCELossLogits": BCEWithLogitsLoss,
"FocalLoss": FocalLoss,
"BinaryCrossEntropy": BCELoss}
decoding_functions = {"greedy_decode": greedy_decode, "simple_decode": simple_decode}
pytorch_opt_dict = {"Adam": Adam, "SGD": SGD, "BertAdam": BertAdam}
<|code_end|>
|
flood_forecast/basic/gru_vanilla.py
<|code_start|>import torch
class VanillaGRU(torch.nn.Module):
def __init__(self, n_time_series: int, hidden_dim: int, num_layers: int, n_target: int, dropout: float,
forecast_length=1, use_hidden=False):
"""
Simple GRU to preform deep time series forecasting.
:param n_time_series:
:type n_time_series:
:param hidden_dim:
:type hidden_dim:
"""
super(VanillaGRU, self).__init__()
# Defining the number of layers and the nodes in each layer
self.layer_dim = num_layers
self.hidden_dim = hidden_dim
self.hidden = None
self.use_hidden = use_hidden
self.forecast_length = forecast_length
# GRU layers
self.gru = torch.nn.GRU(
n_time_series, hidden_dim, num_layers, batch_first=True, dropout=dropout
)
# Fully connected layer
self.fc = torch.nn.Linear(hidden_dim, n_target)
def forward(self, x: torch.Tensor) -> torch.Tensor:
"""Forward function for GRU
:param x: torch of shape
:type model: torch.Tensor
:return: Returns a tensor of shape (batch_size, forecast_length, n_target) or (batch_size, n_target)
:rtype: torch.Tensor
"""
# Initializing hidden state for first input with zeros
if self.hidden is not None and self.use_hidden:
h0 = self.hidden
else:
h0 = torch.zeros(self.layer_dim, x.size(0), self.hidden_dim).requires_grad_()
# Forward propagation by passing in the input and hidden state into the model
out, self.hidden = self.gru(x, h0.detach())
# Reshaping the outputs in the shape of (batch_size, seq_length, hidden_size)
# so that it can fit into the fully connected layer
out = out[:, -self.forecast_length, :]
# Convert the final state to our desired output shape (batch_size, output_dim)
out = self.fc(out)
return out
<|code_end|>
flood_forecast/model_dict_function.py
<|code_start|>from flood_forecast.transformer_xl.multi_head_base import MultiAttnHeadSimple
from flood_forecast.transformer_xl.transformer_basic import SimpleTransformer, CustomTransformerDecoder
from flood_forecast.transformer_xl.informer import Informer
from flood_forecast.transformer_xl.transformer_xl import TransformerXL
from flood_forecast.transformer_xl.dummy_torch import DummyTorchModel
from flood_forecast.basic.linear_regression import SimpleLinearModel
from flood_forecast.basic.lstm_vanilla import LSTMForecast
from flood_forecast.custom.custom_opt import BertAdam
from torch.optim import Adam, SGD
from torch.nn import MSELoss, SmoothL1Loss, PoissonNLLLoss, L1Loss, CrossEntropyLoss, BCELoss, BCEWithLogitsLoss
from flood_forecast.basic.linear_regression import simple_decode
from flood_forecast.transformer_xl.transformer_basic import greedy_decode
from flood_forecast.custom.focal_loss import FocalLoss
from flood_forecast.da_rnn.model import DARNN
from flood_forecast.custom.custom_opt import (RMSELoss, MAPELoss, PenalizedMSELoss, NegativeLogLikelihood, MASELoss,
GaussianLoss)
from flood_forecast.transformer_xl.transformer_bottleneck import DecoderTransformer
from flood_forecast.custom.dilate_loss import DilateLoss
from flood_forecast.meta_models.basic_ae import AE
from flood_forecast.transformer_xl.dsanet import DSANet
from flood_forecast.basic.gru_vanilla import VanillaGRU
"""
Utility dictionaries to map a string to a class
"""
pytorch_model_dict = {
"MultiAttnHeadSimple": MultiAttnHeadSimple,
"SimpleTransformer": SimpleTransformer,
"TransformerXL": TransformerXL,
"DummyTorchModel": DummyTorchModel,
"LSTM": LSTMForecast,
"SimpleLinearModel": SimpleLinearModel,
"CustomTransformerDecoder": CustomTransformerDecoder,
"DARNN": DARNN,
"DecoderTransformer": DecoderTransformer,
"BasicAE": AE,
"Informer": Informer,
"DSANet": DSANet,
"VanillaGRU": VanillaGRU
}
pytorch_criterion_dict = {
"GaussianLoss": GaussianLoss,
"MASELoss": MASELoss,
"MSE": MSELoss,
"SmoothL1Loss": SmoothL1Loss,
"PoissonNLLLoss": PoissonNLLLoss,
"RMSE": RMSELoss,
"MAPE": MAPELoss,
"DilateLoss": DilateLoss,
"L1": L1Loss,
"PenalizedMSELoss": PenalizedMSELoss,
"CrossEntropyLoss": CrossEntropyLoss,
"NegativeLogLikelihood": NegativeLogLikelihood,
"BCELossLogits": BCEWithLogitsLoss,
"FocalLoss": FocalLoss,
"BinaryCrossEntropy": BCELoss}
decoding_functions = {"greedy_decode": greedy_decode, "simple_decode": simple_decode}
pytorch_opt_dict = {"Adam": Adam, "SGD": SGD, "BertAdam": BertAdam}
<|code_end|>
|
geodisplay.py projection not working with any other options but the default
While using the GeographicPlotDisplay function when trying to use other cartopy projections the map extent changes or no data appears.
The default is PlateCarree and works fine but when trying to use a Mercator projection the data shows up but the map extent is changed.
When using a LambertConformal projection the extent appears to be off since no features appear that were suppose to be plotted.
|
act/plotting/GeoDisplay.py
<|code_start|>"""
act.plotting.GeoDisplay
-----------------------
Stores the class for GeographicPlotDisplay.
"""
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from .plot import Display
try:
import cartopy.crs as ccrs
from cartopy.io.img_tiles import Stamen
import cartopy.feature as cfeature
CARTOPY_AVAILABLE = True
except ImportError:
CARTOPY_AVAILABLE = False
class GeographicPlotDisplay(Display):
"""
A class for making geographic tracer plot of aircraft, ship or other moving
platform plot..
This is inherited from the :func:`act.plotting.Display`
class and has therefore has the same attributes as that class.
See :func:`act.plotting.Display`
for more information. There are no additional attributes or parameters
to this class.
In order to create geographic plots, ACT needs the Cartopy package to be
installed on your system. More information about
Cartopy go here:https://scitools.org.uk/cartopy/docs/latest/ .
"""
def __init__(self, obj, ds_name=None, **kwargs):
if not CARTOPY_AVAILABLE:
raise ImportError("Cartopy needs to be installed on your "
"system to make geographic display plots.")
super().__init__(obj, ds_name, **kwargs)
if self.fig is None:
self.fig = plt.figure(**kwargs)
def geoplot(self, data_field=None, lat_field='lat',
lon_field='lon', dsname=None, cbar_label=None, title=None,
projection=ccrs.PlateCarree(), plot_buffer=0.08,
stamen='terrain-background', tile=8, cartopy_feature=None,
cmap='rainbow', text=None, gridlines=True, **kwargs):
"""
Creates a latttude and longitude plot of a time series data set with
data values indicated by color and described with a colorbar.
Latitude values must be in degree north (-90 to 90) and
longitude must be in degree east (-180 to 180).
Parameters
----------
data_field : str
Name of data filed in object to plot.
lat_field : str
Name of latitude field in object to use.
lon_field : str
Name of longitude field in object to use.
dsname : str or None
The name of the datastream to plot. Set to None to make ACT
attempt to automatically determine this.
cbar_label : str
Label to use with colorbar. If set to None will attempt
to create label from long_name and units.
title : str
Plot title.
projection : str
Project to use on plot.
plot_buffer : float
Buffer to add around data on plot in lat and lon dimension.
stamen : str
Dataset to use for background image. Set to None to not use
background image.
tile : int
Tile zoom to use with background image. Higer number indicates
more resolution. A value of 8 is typical for a normal sonde plot.
cartopy_feature : list of str or str
Cartopy feature to add to plot.
cmap : str
Color map to use for colorbar.
text : dictionary
Dictionary of {text:[lon,lat]} to add to plot. Can have more
than one set of text to add.
gridlines : boolean
Use latitude and longitude gridlines.
**kwargs : keyword arguments
Any other keyword arguments that will be passed
into :func:`matplotlib.pyplot.scatter` when the figure
is made. See the matplotlib documentation for further details
on what keyword arguments are available.
"""
# Get current plotting figure
# del self.axes
# if self.fig is None:
# self.fig = plt.figure()
if dsname is None and len(self._arm.keys()) > 1:
raise ValueError(("You must choose a datastream when there are 2 "
"or more datasets in the GeographicPlotDisplay "
"object."))
elif dsname is None:
dsname = list(self._arm.keys())[0]
if data_field is None:
raise ValueError(("You must enter the name of the data "
"to be plotted."))
# Extract data from object
try:
lat = self._arm[dsname][lat_field].values
except KeyError:
raise ValueError(("You will need to provide the name of the "
"field if not '{}' to use for latitued "
"data.").format(lat_field))
try:
lon = self._arm[dsname][lon_field].values
except KeyError:
raise ValueError(("You will need to provide the name of the "
"field if not '{}' to use for longitude "
"data.").format(lon_field))
# Set up metadata information for display on plot
if cbar_label is None:
try:
cbar_label = (
self._arm[dsname][data_field].attrs['long_name'] +
' (' + self._arm[dsname][data_field].attrs['units'] + ')')
except KeyError:
cbar_label = data_field
lat_limits = [np.nanmin(lat), np.nanmax(lat)]
lon_limits = [np.nanmin(lon), np.nanmax(lon)]
box_size = np.max([np.abs(np.diff(lat_limits)),
np.abs(np.diff(lon_limits))])
bx_buf = box_size * plot_buffer
lat_center = np.sum(lat_limits) / 2.
lon_center = np.sum(lon_limits) / 2.
lat_limits = [lat_center - box_size / 2. - bx_buf,
lat_center + box_size / 2. + bx_buf]
lon_limits = [lon_center - box_size / 2. - bx_buf,
lon_center + box_size / 2. + bx_buf]
data = self._arm[dsname][data_field].values
# Create base plot projection
ax = plt.axes(projection=projection)
plt.subplots_adjust(left=0.01, right=0.99, bottom=0.05, top=0.93)
ax.set_extent([lon_limits[0], lon_limits[1], lat_limits[0],
lat_limits[1]], crs=projection)
if title is None:
try:
dim = list(self._arm[dsname][data_field].dims)
ts = pd.to_datetime(str(self._arm[dsname][dim[0]].values[0]))
date = ts.strftime('%Y-%m-%d')
time_str = ts.strftime('%H:%M:%S')
plt.title(' '.join([dsname, 'at', date, time_str]))
except NameError:
plt.title(dsname)
else:
plt.title(title)
if stamen:
tiler = Stamen(stamen)
ax.add_image(tiler, tile)
colorbar_map = None
if cmap is not None:
colorbar_map = plt.cm.get_cmap(cmap)
sc = ax.scatter(lon, lat, c=data, cmap=colorbar_map, **kwargs)
cbar = plt.colorbar(sc)
cbar.ax.set_ylabel(cbar_label)
if cartopy_feature is not None:
if isinstance(cartopy_feature, str):
cartopy_feature = [cartopy_feature]
cartopy_feature = [ii.upper() for ii in cartopy_feature]
if 'STATES' in cartopy_feature:
ax.add_feature(cfeature.STATES.with_scale('10m'))
if 'LAND' in cartopy_feature:
ax.add_feature(cfeature.LAND)
if 'OCEAN' in cartopy_feature:
ax.add_feature(cfeature.OCEAN)
if 'COASTLINE' in cartopy_feature:
ax.add_feature(cfeature.COASTLINE)
if 'BORDERS' in cartopy_feature:
ax.add_feature(cfeature.BORDERS, linestyle=':')
if 'LAKES' in cartopy_feature:
ax.add_feature(cfeature.LAKES, alpha=0.5)
if 'RIVERS' in cartopy_feature:
ax.add_feature(cfeature.RIVERS)
if text is not None:
for label, location in text.items():
ax.plot(location[0], location[1], marker='*', color='black')
ax.text(location[0], location[1], label, color='black')
if gridlines:
gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True,
linewidth=1, color='gray', alpha=0.5,
linestyle='--')
gl.xlabels_top = False
gl.ylabels_left = True
gl.xlabels_bottom = True
gl.ylabels_right = False
gl.xlabel_style = {'size': 6, 'color': 'gray'}
gl.ylabel_style = {'size': 6, 'color': 'gray'}
return ax
<|code_end|>
|
act/plotting/GeoDisplay.py
<|code_start|>"""
act.plotting.GeoDisplay
-----------------------
Stores the class for GeographicPlotDisplay.
"""
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from .plot import Display
try:
import cartopy.crs as ccrs
from cartopy.io.img_tiles import Stamen
import cartopy.feature as cfeature
CARTOPY_AVAILABLE = True
except ImportError:
CARTOPY_AVAILABLE = False
class GeographicPlotDisplay(Display):
"""
A class for making geographic tracer plot of aircraft, ship or other moving
platform plot..
This is inherited from the :func:`act.plotting.Display`
class and has therefore has the same attributes as that class.
See :func:`act.plotting.Display`
for more information. There are no additional attributes or parameters
to this class.
In order to create geographic plots, ACT needs the Cartopy package to be
installed on your system. More information about
Cartopy go here:https://scitools.org.uk/cartopy/docs/latest/ .
"""
def __init__(self, obj, ds_name=None, **kwargs):
if not CARTOPY_AVAILABLE:
raise ImportError("Cartopy needs to be installed on your "
"system to make geographic display plots.")
super().__init__(obj, ds_name, **kwargs)
if self.fig is None:
self.fig = plt.figure(**kwargs)
def geoplot(self, data_field=None, lat_field='lat',
lon_field='lon', dsname=None, cbar_label=None, title=None,
projection=ccrs.PlateCarree(), plot_buffer=0.08,
stamen='terrain-background', tile=8, cartopy_feature=None,
cmap='rainbow', text=None, gridlines=True, **kwargs):
"""
Creates a latttude and longitude plot of a time series data set with
data values indicated by color and described with a colorbar.
Latitude values must be in degree north (-90 to 90) and
longitude must be in degree east (-180 to 180).
Parameters
----------
data_field : str
Name of data filed in object to plot.
lat_field : str
Name of latitude field in object to use.
lon_field : str
Name of longitude field in object to use.
dsname : str or None
The name of the datastream to plot. Set to None to make ACT
attempt to automatically determine this.
cbar_label : str
Label to use with colorbar. If set to None will attempt
to create label from long_name and units.
title : str
Plot title.
projection : cartopy.crs object
Project to use on plot. See
https://scitools.org.uk/cartopy/docs/latest/crs/projections.html
plot_buffer : float
Buffer to add around data on plot in lat and lon dimension.
stamen : str
Dataset to use for background image. Set to None to not use
background image.
tile : int
Tile zoom to use with background image. Higer number indicates
more resolution. A value of 8 is typical for a normal sonde plot.
cartopy_feature : list of str or str
Cartopy feature to add to plot.
cmap : str
Color map to use for colorbar.
text : dictionary
Dictionary of {text:[lon,lat]} to add to plot. Can have more
than one set of text to add.
gridlines : boolean
Use latitude and longitude gridlines.
**kwargs : keyword arguments
Any other keyword arguments that will be passed
into :func:`matplotlib.pyplot.scatter` when the figure
is made. See the matplotlib documentation for further details
on what keyword arguments are available.
"""
# Get current plotting figure
# del self.axes
# if self.fig is None:
# self.fig = plt.figure()
if dsname is None and len(self._arm.keys()) > 1:
raise ValueError(("You must choose a datastream when there are 2 "
"or more datasets in the GeographicPlotDisplay "
"object."))
elif dsname is None:
dsname = list(self._arm.keys())[0]
if data_field is None:
raise ValueError(("You must enter the name of the data "
"to be plotted."))
# Extract data from object
try:
lat = self._arm[dsname][lat_field].values
except KeyError:
raise ValueError(("You will need to provide the name of the "
"field if not '{}' to use for latitued "
"data.").format(lat_field))
try:
lon = self._arm[dsname][lon_field].values
except KeyError:
raise ValueError(("You will need to provide the name of the "
"field if not '{}' to use for longitude "
"data.").format(lon_field))
# Set up metadata information for display on plot
if cbar_label is None:
try:
cbar_label = (
self._arm[dsname][data_field].attrs['long_name'] +
' (' + self._arm[dsname][data_field].attrs['units'] + ')')
except KeyError:
cbar_label = data_field
lat_limits = [np.nanmin(lat), np.nanmax(lat)]
lon_limits = [np.nanmin(lon), np.nanmax(lon)]
box_size = np.max([np.abs(np.diff(lat_limits)),
np.abs(np.diff(lon_limits))])
bx_buf = box_size * plot_buffer
lat_center = np.sum(lat_limits) / 2.
lon_center = np.sum(lon_limits) / 2.
lat_limits = [lat_center - box_size / 2. - bx_buf,
lat_center + box_size / 2. + bx_buf]
lon_limits = [lon_center - box_size / 2. - bx_buf,
lon_center + box_size / 2. + bx_buf]
data = self._arm[dsname][data_field].values
# Create base plot projection
ax = plt.axes(projection=projection)
plt.subplots_adjust(left=0.01, right=0.99, bottom=0.05, top=0.93)
ax.set_extent([lon_limits[0], lon_limits[1], lat_limits[0],
lat_limits[1]], crs=projection)
if title is None:
try:
dim = list(self._arm[dsname][data_field].dims)
ts = pd.to_datetime(str(self._arm[dsname][dim[0]].values[0]))
date = ts.strftime('%Y-%m-%d')
time_str = ts.strftime('%H:%M:%S')
plt.title(' '.join([dsname, 'at', date, time_str]))
except NameError:
plt.title(dsname)
else:
plt.title(title)
if stamen:
tiler = Stamen(stamen)
ax.add_image(tiler, tile)
colorbar_map = None
if cmap is not None:
colorbar_map = plt.cm.get_cmap(cmap)
sc = ax.scatter(lon, lat, c=data, cmap=colorbar_map, **kwargs)
cbar = plt.colorbar(sc)
cbar.ax.set_ylabel(cbar_label)
if cartopy_feature is not None:
if isinstance(cartopy_feature, str):
cartopy_feature = [cartopy_feature]
cartopy_feature = [ii.upper() for ii in cartopy_feature]
if 'STATES' in cartopy_feature:
ax.add_feature(cfeature.STATES.with_scale('10m'))
if 'LAND' in cartopy_feature:
ax.add_feature(cfeature.LAND)
if 'OCEAN' in cartopy_feature:
ax.add_feature(cfeature.OCEAN)
if 'COASTLINE' in cartopy_feature:
ax.add_feature(cfeature.COASTLINE)
if 'BORDERS' in cartopy_feature:
ax.add_feature(cfeature.BORDERS, linestyle=':')
if 'LAKES' in cartopy_feature:
ax.add_feature(cfeature.LAKES, alpha=0.5)
if 'RIVERS' in cartopy_feature:
ax.add_feature(cfeature.RIVERS)
if text is not None:
for label, location in text.items():
ax.plot(location[0], location[1], marker='*', color='black')
ax.text(location[0], location[1], label, color='black')
if gridlines:
if projection == ccrs.PlateCarree() or projection == ccrs.Mercator:
gl = ax.gridlines(crs=projection, draw_labels=True,
linewidth=1, color='gray', alpha=0.5,
linestyle='--')
gl.xlabels_top = False
gl.ylabels_left = True
gl.xlabels_bottom = True
gl.ylabels_right = False
gl.xlabel_style = {'size': 6, 'color': 'gray'}
gl.ylabel_style = {'size': 6, 'color': 'gray'}
else:
# Labels are only currently supported for PlateCarree and Mercator
gl = ax.gridlines(draw_labels=False, linewidth=1, color='gray',
alpha=0.5, linestyle='--')
return ax
<|code_end|>
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 21