Coverage for website/events/api/v2/admin/views.py: 60.47%

1from django.http import Http404 

2 

3from oauth2_provider.contrib.rest_framework import IsAuthenticatedOrTokenHasScope 

4from rest_framework import filters as framework_filters 

5from rest_framework import status 

6from rest_framework.exceptions import ValidationError 

7from rest_framework.generics import get_object_or_404 

8from rest_framework.response import Response 

9from rest_framework.views import APIView 

10 

11import events.api.v2.filters as normal_filters 

12from events import services 

13from events.api.v2.admin import filters 

14from events.api.v2.admin.permissions import IsOrganiser 

15from events.api.v2.admin.serializers.event import ( 

16 EventAdminSerializer, 

17 EventListAdminSerializer, 

18) 

19from events.api.v2.admin.serializers.event_registration import ( 

20 EventRegistrationAdminSerializer, 

21) 

22from events.models import Event, EventRegistration 

23from thaliawebsite.api.v2.admin.views import ( 

24 AdminCreateAPIView, 

25 AdminDestroyAPIView, 

26 AdminListAPIView, 

27 AdminPermissionsMixin, 

28 AdminRetrieveAPIView, 

29 AdminUpdateAPIView, 

30) 

31 

32 

33class EventAdminListCreateAPIView(AdminListAPIView, AdminCreateAPIView): 

34 queryset = Event.objects.prefetch_related("organisers") 

35 permission_classes = [IsAuthenticatedOrTokenHasScope] 

36 required_scopes = ["events:admin"] 

37 filter_backends = [ 

38 framework_filters.OrderingFilter, 

39 normal_filters.CategoryFilter, 

40 normal_filters.OrganiserFilter, 

41 normal_filters.EventDateFilter, 

42 filters.PublishedFilter, 

43 ] 

44 ordering_fields = ( 

45 "start", 

46 "end", 

47 "published", 

48 "registration_start", 

49 "registration_end", 

50 ) 

51 

52 def get_serializer_class(self): 

53 if self.request.method.lower() == "post": 

54 return EventAdminSerializer 

55 return EventListAdminSerializer 

56 

57 

58class EventAdminDetailAPIView( 

59 AdminRetrieveAPIView, AdminUpdateAPIView, AdminDestroyAPIView 

60): 

61 queryset = Event.objects.all() 

62 serializer_class = EventAdminSerializer 

63 permission_classes = [IsOrganiser, IsAuthenticatedOrTokenHasScope] 

64 required_scopes = ["events:admin"] 

65 

66 

67class EventRegistrationAdminListView(AdminListAPIView, AdminCreateAPIView): 

68 """Returns a list of registrations.""" 

69 

70 serializer_class = EventRegistrationAdminSerializer 

71 permission_classes = [IsOrganiser, IsAuthenticatedOrTokenHasScope] 

72 required_scopes = ["events:admin"] 

73 filter_backends = ( 

74 framework_filters.OrderingFilter, 

75 framework_filters.SearchFilter, 

76 filters.EventRegistrationCancelledFilter, 

77 filters.EventRegistrationQueuedFilter, 

78 ) 

79 ordering_fields = ("queue_position", "date", "date_cancelled") 

80 search_fields = ( 

81 "member__first_name", 

82 "member__last_name", 

83 "name", 

84 ) 

85 

86 def get_queryset(self): 

87 event = get_object_or_404(Event, pk=self.kwargs.get("pk")) 

88 if event: 

89 return EventRegistration.objects.filter(event_id=event).prefetch_related( 

90 "member", "member__profile" 

91 ) 

92 return EventRegistration.objects.none() 

93 

94 def get_serializer_context(self): 

95 context = super().get_serializer_context() 

96 event = Event.objects.filter(pk=self.kwargs.get("pk")).first() 

97 context.update({"event": event}) 

98 return context 

99 

100 

101class EventRegistrationAdminDetailView( 

102 AdminRetrieveAPIView, AdminUpdateAPIView, AdminDestroyAPIView 

103): 

104 """Returns details of an event registration.""" 

105 

106 serializer_class = EventRegistrationAdminSerializer 

107 queryset = EventRegistration.objects.all() 

108 permission_classes = [IsOrganiser, IsAuthenticatedOrTokenHasScope] 

109 required_scopes = ["events:admin"] 

110 event_lookup_field = "event_id" 

111 

112 def get_queryset(self): 

113 return super().get_queryset().filter(event=self.kwargs[self.event_lookup_field]) 

114 

115 

116class EventRegistrationAdminFieldsView(AdminPermissionsMixin, APIView): 

117 """Returns details of an event registration.""" 

118 

119 permission_classes = [IsOrganiser, IsAuthenticatedOrTokenHasScope] 

120 required_scopes = ["events:admin"] 

121 

122 def get_queryset(self): 

123 return EventRegistration.objects.filter(event=self.kwargs["event_id"]) 

124 

125 def get_object(self): 

126 event_registration = get_object_or_404( 

127 EventRegistration, 

128 event=self.kwargs["event_id"], 

129 pk=self.kwargs["registration_id"], 

130 ) 

131 

132 if not event_registration.event.has_fields: 

133 raise Http404 

134 

135 return event_registration 

136 

137 def get(self, request, *args, **kwargs): 

138 return Response( 

139 data=services.registration_fields(request, registration=self.get_object()), 

140 status=status.HTTP_200_OK, 

141 ) 

142 

143 def put(self, request, *args, **kwargs): 

144 original = services.registration_fields(request, registration=self.get_object()) 

145 required_keys = set(original.keys()) - set(request.data.keys()) 

146 if len(required_keys) > 0: 

147 raise ValidationError( 

148 f"Missing keys '{', '.join(required_keys)}' in request", 

149 status.HTTP_400_BAD_REQUEST, 

150 ) 

151 

152 services.update_registration( 

153 registration=self.get_object(), field_values=request.data.items() 

154 ) 

155 

156 return Response( 

157 data=services.registration_fields(request, registration=self.get_object()), 

158 status=status.HTTP_200_OK, 

159 ) 

160 

161 def patch(self, request, *args, **kwargs): 

162 services.update_registration( 

163 registration=self.get_object(), field_values=request.data.items() 

164 ) 

165 

166 return Response( 

167 data=services.registration_fields(request, registration=self.get_object()), 

168 status=status.HTTP_200_OK, 

169 )