class SessionViewSet(get_viewset_transition_action_mixin(Session),
viewsets.ModelViewSet):
queryset = Session.objects.select_related('convention', ).prefetch_related(
'contests',
'contests__contestants',
'contests__award',
'entries',
'entries__participants',
'entries__contestants',
'entries__appearances',
'entries__group',
'rounds__appearances',
'rounds__slots',
'rounds__panelists',
'grantors',
).order_by('nomen')
serializer_class = SessionSerializer
filter_class = SessionFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "session"
class EntryViewSet(get_viewset_transition_action_mixin(Entry),
viewsets.ModelViewSet):
queryset = Entry.objects.select_related(
'session',
'group',
).prefetch_related(
'appearances',
'appearances__songs',
'appearances__round',
'appearances__slot',
'contestants',
'contestants__contest',
'participants',
'participants__member',
).order_by('nomen')
serializer_class = EntrySerializer
filter_class = EntryFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "entry"
class RelationshipViewSet(
IdentitySubViewMixin,
get_viewset_transition_action_mixin(models.Affiliation, 'state'),
get_viewset_transition_action_mixin(models.Affiliation, 'suspended'),
viewsets.ModelViewSet):
def get_suspend_kwargs(self):
data = self.request.data
if 'until' in data:
try:
until = dateutil.parser.parse(data['until'])
if not until.tzinfo:
until = timezone.make_aware(until)
return {'until': until}
except ValueError:
raise ValidationError(
{'detail': '"until" should be a datetime if specified'})
return {}
class OrganizationViewSet(get_viewset_transition_action_mixin(Organization),
viewsets.ModelViewSet):
queryset = Organization.objects.select_related(
'parent', ).prefetch_related(
'awards',
'awards__contests',
'awards__parent',
'awards__children',
'conventions',
'conventions__sessions',
'conventions__assignments',
'conventions__venue',
'groups',
'officers',
'officers__person',
'officers__office',
'children',
'children__awards',
'children__conventions',
'children__officers',
'children__children',
).order_by('nomen', )
serializer_class = OrganizationSerializer
filter_class = OrganizationFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "organization"
@detail_route(methods=['POST'], permission_classes=[AllowAny])
@parser_classes((
FormParser,
MultiPartParser,
))
def image(self, request, *args, **kwargs):
print(request.data)
if 'file' in request.data:
obj = self.get_object()
upload = request.data['file']
obj.image.save(
'foo.jpg',
upload,
)
return Response(
status=status.HTTP_201_CREATED,
data={'image': obj.image.url},
)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
class RepertoryViewSet(get_viewset_transition_action_mixin(Repertory),
viewsets.ModelViewSet):
queryset = Repertory.objects.select_related(
'group',
'chart',
).prefetch_related().order_by('nomen')
serializer_class = RepertorySerializer
filter_class = None
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "repertory"
class OfficerViewSet(get_viewset_transition_action_mixin(Officer),
viewsets.ModelViewSet):
queryset = Officer.objects.select_related(
'office',
'person',
'organization',
).prefetch_related().order_by('nomen')
serializer_class = OfficerSerializer
filter_class = OfficerFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "officer"
class GroupViewSet(get_viewset_transition_action_mixin(Group),
viewsets.ModelViewSet):
queryset = Group.objects.select_related('organization', ).prefetch_related(
'entries',
'entries__appearances',
'entries__contestants',
'entries__session',
'entries__participants',
'members__participants',
'members__person',
'repertories',
'repertories__chart',
).order_by('nomen', )
serializer_class = GroupSerializer
filter_class = GroupFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "group"
@detail_route(methods=['POST'], permission_classes=[AllowAny])
@parser_classes((
FormParser,
MultiPartParser,
))
def image(self, request, *args, **kwargs):
print(request.data)
if 'file' in request.data:
obj = self.get_object()
upload = request.data['file']
obj.image.save(
'foo.jpg',
upload,
)
return Response(
status=status.HTTP_201_CREATED,
data={'image': obj.image.url},
)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
class AssignmentViewSet(
get_viewset_transition_action_mixin(Assignment),
viewsets.ModelViewSet,
):
queryset = Assignment.objects.select_related(
'convention',
'person',
).prefetch_related().order_by('nomen')
serializer_class = AssignmentSerializer
filter_class = None
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "assignment"
class MemberViewSet(get_viewset_transition_action_mixin(Member),
viewsets.ModelViewSet):
queryset = Member.objects.select_related(
'group',
'person',
).prefetch_related(
'participants',
'participants__entry',
).order_by('nomen')
serializer_class = MemberSerializer
filter_class = MemberFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "member"
class AwardViewSet(get_viewset_transition_action_mixin(Award),
viewsets.ModelViewSet):
queryset = Award.objects.select_related(
'organization',
'parent',
).prefetch_related(
'children',
'contests',
).order_by('status', 'nomen')
serializer_class = AwardSerializer
filter_class = AwardFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "award"
class PersonViewSet(get_viewset_transition_action_mixin(
models.Person, 'state'), IdentityViewSet):
permission_classes = (permissions.IsAuthenticated, )
queryset = models.Person.objects.all()
serializer_class = serializers.PersonSerializer
filter_backends = (
IdentityPermissionFilterBackend,
IdentifierFilterBackend,
)
def get_queryset(self):
queryset = super().get_queryset()
if 'affiliationOrganization' in self.request.GET:
organization_ids = self.request.GET.getlist(
'affiliationOrganization')
states = self.request.GET.getlist('affiliationState') or (
'active', )
affiliations = Affiliation.objects.filter(
organization_id__in=organization_ids, state__in=states)
if 'affiliationType' in self.request.GET:
affiliations = affiliations.filter(
type_id__in=self.request.GET.getlist('affiliationType'))
queryset = queryset.filter(affiliation=affiliations)
return queryset
@detail_route(methods=['post'])
def merge(self, request, pk=None):
with transaction.atomic():
identity = self.get_object()
other_ids = request.POST.getlist('id')
others = self.get_queryset().filter(pk__in=other_ids,
state__in=('established',
'active'))
if others.count() != len(other_ids):
missing_ids = sorted(
set(other_ids) - set(others.values_list('pk', flat=True)))
raise ValidationError(
"Couldn't find identities for IDs {}, or not in suitable state"
.format(', '.join(missing_ids)))
identity.merge(others)
return HttpResponse(status=204)
class ChartViewSet(
get_viewset_transition_action_mixin(Chart),
viewsets.ModelViewSet,
):
queryset = Chart.objects.select_related().prefetch_related(
'repertories',
'songs',
).order_by('status', 'nomen')
serializer_class = ChartSerializer
filter_class = ChartFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "chart"
@detail_route(methods=['POST'], permission_classes=[AllowAny])
@parser_classes((
FormParser,
MultiPartParser,
))
def image(self, request, *args, **kwargs):
print(request.data)
if 'file' in request.data:
obj = self.get_object()
upload = request.data['file']
obj.image.save(
'foo.pdf',
upload,
)
return Response(
status=status.HTTP_201_CREATED,
data={'image': obj.image.url},
)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
class AppearanceViewSet(
get_viewset_transition_action_mixin(Appearance),
viewsets.ModelViewSet,
):
queryset = Appearance.objects.select_related(
'round',
'entry',
'slot',
).prefetch_related(
'songs',
'songs__scores',
'songs__chart',
).order_by('nomen')
serializer_class = AppearanceSerializer
filter_class = None
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "appearance"
@detail_route(methods=['POST'], permission_classes=[AllowAny])
@parser_classes((
FormParser,
MultiPartParser,
))
def print_var(self, request, *args, **kwargs):
obj = self.get_object()
obj.print_var()
# return Response(
# status=status.HTTP_200_OK,
# data={'var_pdf': obj.var_pdf.url},
# )
serializer = self.get_serializer(obj)
return Response(serializer.data)
class ConventionViewSet(get_viewset_transition_action_mixin(Convention),
viewsets.ModelViewSet):
queryset = Convention.objects.select_related(
'venue',
'organization',
).prefetch_related(
'sessions',
'sessions__rounds',
'sessions__contests',
'sessions__entries',
'assignments',
'assignments__person',
).order_by('nomen')
serializer_class = ConventionSerializer
filter_class = ConventionFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "convention"
class RoundViewSet(get_viewset_transition_action_mixin(Round),
viewsets.ModelViewSet):
queryset = Round.objects.select_related('session', ).prefetch_related(
'appearances',
'appearances__songs',
'appearances__entry',
'appearances__slot',
'slots',
'slots__round',
'slots__appearance',
'panelists',
'panelists__person',
'panelists__scores',
).order_by('nomen')
serializer_class = RoundSerializer
filter_class = RoundFilter
filter_backends = [
CoalesceFilterBackend,
DjangoFilterBackend,
]
permission_classes = [
DRYPermissions,
]
resource_name = "round"
@detail_route(methods=['POST'], permission_classes=[AllowAny])
@parser_classes((
FormParser,
MultiPartParser,
))
def print_ann(self, request, *args, **kwargs):
obj = self.get_object()
obj.print_ann()
serializer = self.get_serializer(obj)
return Response(serializer.data)
