class AGTestSuiteListCreateView(ListCreateNestedModelViewSet):
serializer_class = ag_serializers.AGTestSuiteSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda project: project.course)
]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related(
'course').prefetch_related(
Prefetch(
'ag_test_suites',
ag_models.AGTestSuite.objects.select_related(
'project__course', ).prefetch_related(
Prefetch(
'instructor_files_needed',
ag_models.InstructorFile.objects.select_related(
'project')),
Prefetch(
'student_files_needed',
ag_models.ExpectedStudentFile.objects.
select_related('project')),
Prefetch(
'ag_test_cases',
ag_models.AGTestCase.objects.select_related(
'ag_test_suite', ).prefetch_related(
Prefetch(
'ag_test_commands',
ag_models.AGTestCommand.objects.
select_related('ag_test_case')))))))
to_one_field_name = 'project'
reverse_to_one_field_name = 'ag_test_suites'
class AGTestSuiteOrderView(AGModelAPIView):
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda project: project.course)
]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related('course')
api_tags = [APITags.ag_test_suites]
@swagger_auto_schema(responses={
'200':
'Returns a list of AGTestSuite IDs, in their assigned order.'
})
def get(self, *args, **kwargs):
project = self.get_object()
return response.Response(list(project.get_agtestsuite_order()))
@swagger_auto_schema(
request_body_parameters=[
Parameter(name='',
in_='body',
type='List[string]',
description=
'A list of AGTestSuite IDs, in the new order to set.')
],
responses={
'200': 'Returns a list of AGTestSuite IDs, in their new order.'
})
def put(self, request, *args, **kwargs):
with transaction.atomic():
project = self.get_object()
project.set_agtestsuite_order(request.data)
return response.Response(list(project.get_agtestsuite_order()))
class CriterionListCreateView(ListCreateNestedModelViewSet):
serializer_class = handgrading_serializers.CriterionSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda handgrading_rubric: handgrading_rubric.project.course)
]
pk_key = 'handgrading_rubric_pk'
model_manager = hg_models.HandgradingRubric.objects.select_related(
'project__course')
to_one_field_name = 'handgrading_rubric'
reverse_to_one_field_name = 'criteria'
@transaction.atomic()
def create(self, request, *args, **kwargs):
handgrading_rubric = self.get_object()
# Create criterion first
criterion_response = super().create(request=request)
criterion = hg_models.Criterion.objects.get(**criterion_response.data)
results = hg_models.HandgradingResult.objects.filter(
handgrading_rubric=handgrading_rubric)
# Create CriterionResult for every HandgradingResult with the same HandgradingRubric
for result in results:
hg_models.CriterionResult.objects.validate_and_create(
selected=False, criterion=criterion, handgrading_result=result)
return criterion_response
class AGTestCaseDetailViewSet(TransactionRetrievePatchDestroyMixin,
AGModelGenericViewSet):
serializer_class = ag_serializers.AGTestCaseSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda ag_test_case: ag_test_case.ag_test_suite.project.course)
]
model_manager = ag_models.AGTestCase.objects.select_related(
'ag_test_suite__project__course', )
class HandgradingRubricDetailViewSet(TransactionRetrievePatchDestroyMixin,
AGModelGenericViewSet):
serializer_class = handgrading_serializers.HandgradingRubricSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda handgrading_rubric: handgrading_rubric.project.course)
]
model_manager = handgrading_models.HandgradingRubric.objects.select_related(
'project__course', ).prefetch_related('criteria', 'annotations')
class StudentTestSuiteDetailViewSet(TransactionRetrievePatchDestroyMixin,
AGModelGenericViewSet):
serializer_class = ag_serializers.StudentTestSuiteSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda student_suite: student_suite.project.course)
]
model_manager = ag_models.StudentTestSuite.objects
class AnnotationDetailViewSet(TransactionRetrievePatchDestroyMixin,
AGModelGenericViewSet):
serializer_class = handgrading_serializers.AnnotationSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda annotation: annotation.handgrading_rubric.project.course)
]
model_manager = handgrading_models.Annotation.objects.select_related(
'handgrading_rubric__project__course', )
class StudentTestSuiteListCreateView(ListCreateNestedModelViewSet):
serializer_class = ag_serializers.StudentTestSuiteSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda project: project.course)
]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related('course')
to_one_field_name = 'project'
reverse_to_one_field_name = 'student_test_suites'
class AGTestCaseListCreateView(ListCreateNestedModelViewSet):
serializer_class = ag_serializers.AGTestCaseSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda ag_test_suite: ag_test_suite.project.course)
]
pk_key = 'ag_test_suite_pk'
model_manager = ag_models.AGTestSuite.objects.select_related(
'project__course')
to_one_field_name = 'ag_test_suite'
reverse_to_one_field_name = 'ag_test_cases'
class AnnotationListCreateView(ListCreateNestedModelViewSet):
serializer_class = handgrading_serializers.AnnotationSerializer
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda handgrading_rubric: handgrading_rubric.project.course)
]
pk_key = 'handgrading_rubric_pk'
model_manager = handgrading_models.HandgradingRubric.objects.select_related(
'project__course')
to_one_field_name = 'handgrading_rubric'
reverse_to_one_field_name = 'annotations'
class CourseHandgradersViewSet(ListNestedModelViewSet):
serializer_class = ag_serializers.UserSerializer
permission_classes = (ag_permissions.is_admin_or_read_only_staff(), )
model_manager = ag_models.Course.objects
reverse_to_one_field_name = 'handgraders'
api_tags = [APITags.permissions]
@swagger_auto_schema(responses={'204': ''},
request_body_parameters=_add_handgraders_params)
@transaction.atomic()
@method_decorator(require_body_params('new_handgraders'))
def post(self, request, *args, **kwargs):
course = self.get_object()
self.add_handgraders(course, request.data['new_handgraders'])
return response.Response(status=status.HTTP_204_NO_CONTENT)
@swagger_auto_schema(responses={'204': ''},
request_body_parameters=_remove_handgraders_params)
@transaction.atomic()
@method_decorator(require_body_params('remove_handgraders'))
def patch(self, request, *args, **kwargs):
course = self.get_object()
self.remove_handgraders(course, request.data['remove_handgraders'])
return response.Response(status=status.HTTP_204_NO_CONTENT)
def add_handgraders(self, course: ag_models.Course, usernames):
handgraders_to_add = [
User.objects.get_or_create(username=username)[0]
for username in usernames
]
course.handgraders.add(*handgraders_to_add)
def remove_handgraders(self, course: ag_models.Course, users_json):
handgraders_to_remove = User.objects.filter(
pk__in=[user['pk'] for user in users_json])
course.handgraders.remove(*handgraders_to_remove)
@classmethod
def as_view(cls, actions=None, **initkwargs):
return super().as_view(actions={
'get': 'list',
'post': 'post',
'patch': 'patch'
},
**initkwargs)
class AnnotationOrderView(AGModelAPIView):
permission_classes = [
ag_permissions.is_admin_or_read_only_staff(
lambda handgrading_rubric: handgrading_rubric.project.course)
]
pk_key = 'handgrading_rubric_pk'
model_manager = handgrading_models.HandgradingRubric.objects.select_related(
'project__course')
api_tags = [APITags.annotations]
@swagger_auto_schema(responses={
'200':
'Returns a list of Annotation IDs, in their assigned order.'
})
def get(self, request, *args, **kwargs):
handgrading_rubric = self.get_object()
return response.Response(
list(handgrading_rubric.get_annotation_order()))
@swagger_auto_schema(
request_body_parameters=[
Parameter(
name='',
in_='body',
type='List[string]',
description='A list of Annotation IDs, in the new order to set.'
)
],
responses={
'200': 'Returns a list of Annotation IDs, in their new order.'
})
def put(self, request, *args, **kwargs):
with transaction.atomic():
handgrading_rubric = self.get_object()
handgrading_rubric.set_annotation_order(request.data)
return response.Response(
list(handgrading_rubric.get_annotation_order()))
from django.core.exceptions import ObjectDoesNotExist
from django.http import Http404
from drf_composable_permissions.p import P
from rest_framework import response
import autograder.core.models as ag_models
import autograder.handgrading.models as handgrading_models
import autograder.handgrading.serializers as handgrading_serializers
import autograder.rest_api.permissions as ag_permissions
from autograder.rest_api.views.ag_model_views import (
AGModelGenericViewSet, TransactionRetrievePatchDestroyMixin,
RetrieveCreateNestedModelViewSet)
from autograder.rest_api.views.schema_generation import APITags
is_admin_or_read_only = ag_permissions.is_admin_or_read_only_staff(
lambda project: project.course)
is_handgrader = ag_permissions.is_handgrader(lambda project: project.course)
class HandgradingRubricRetrieveCreateViewSet(RetrieveCreateNestedModelViewSet):
serializer_class = handgrading_serializers.HandgradingRubricSerializer
permission_classes = [(P(is_admin_or_read_only) |
(P(is_handgrader) & P(ag_permissions.IsReadOnly)))]
pk_key = 'project_pk'
model_manager = ag_models.Project.objects.select_related('course')
to_one_field_name = 'project'
reverse_to_one_field_name = 'handgrading_rubric'
api_tags = [APITags.handgrading_rubrics]
