add Questionnaire and QuestionnaireChild models and their API; migrate existing data

src/pretix/api/serializers/item.py

@@ -51,6 +51,7 @@ from pretix.base.models import (
     ItemVariation, ItemVariationMetaValue, Question, QuestionOption, Quota,
     SalesChannel,
 )
+from pretix.base.models.items import Questionnaire, QuestionnaireChild
 
 
 class InlineItemVariationSerializer(SalesChannelMigrationMixin, I18nAwareModelSerializer):
@@ -624,6 +625,160 @@ class QuestionSerializer(I18nAwareModelSerializer):
         return question
 
 
+class QuestionRefField(serializers.PrimaryKeyRelatedField):
+    def to_representation(self, qc):
+        if not qc:
+            return None
+        elif qc.system_question:
+            return qc.system_question
+        elif qc.user_question_id:
+            return qc.user_question_id
+        else:
+            return None
+
+    def to_internal_value(self, data):
+        if type(data) == int:
+            return {'user_question': super().to_internal_value(data), 'system_question': None}
+        elif type(data) == str or data is None:
+            return {'user_question': None, 'system_question': data}
+        else:
+            self.fail('incorrect_type', data_type=type(data).__name__)
+
+    def use_pk_only_optimization(self):
+        return self.source == '*'
+
+
+class InlineQuestionnaireChildSerializer(I18nAwareModelSerializer):
+    question = QuestionRefField(source='*', queryset=Question.objects.none())
+    dependency_question = QuestionRefField(allow_null=True, required=False, queryset=Question.objects.none())
+
+    class Meta:
+        model = QuestionnaireChild
+        fields = ('question', 'required', 'label', 'help_text', 'dependency_question', 'dependency_values')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["question"].queryset = self.context["event"].questions.all()
+        self.fields["dependency_question"].queryset = self.context["event"].questions.all()
+
+    def validate(self, data):
+        data = super().validate(data)
+        event = self.context['event']
+
+        full_data = self.to_internal_value(self.to_representation(self.instance)) if self.instance else {}
+        full_data.update(data)
+
+        if full_data.get('ask_during_checkin') and full_data.get('dependency_question'):
+            raise ValidationError('Dependencies are not supported during check-in.')
+
+        dep = full_data.get('dependency_question')
+        if dep:
+            if dep.ask_during_checkin:
+                raise ValidationError(_('Question cannot depend on a question asked during check-in.'))
+
+            seen_ids = {self.instance.pk} if self.instance else set()
+            while dep:
+                if dep.pk in seen_ids:
+                    raise ValidationError(_('Circular dependency between questions detected.'))
+                seen_ids.add(dep.pk)
+                dep = dep.dependency_question
+
+        return data
+
+    def validate_dependency_question(self, value):
+        if value:
+            if value.type not in (Question.TYPE_CHOICE, Question.TYPE_BOOLEAN, Question.TYPE_CHOICE_MULTIPLE):
+                raise ValidationError('Question dependencies can only be set to boolean or choice questions.')
+            if value == self.instance:
+                raise ValidationError('A question cannot depend on itself.')
+        return value
+
+
+class QuestionnaireSerializer(I18nAwareModelSerializer):
+    limit_sales_channels = serializers.SlugRelatedField(
+        slug_field="identifier",
+        queryset=SalesChannel.objects.none(),
+        required=False,
+        allow_empty=True,
+        many=True,
+    )
+
+    class Meta:
+        model = Questionnaire
+        fields = ('id', 'type', 'internal_name', 'items', 'position', 'all_sales_channels', 'limit_sales_channels', 'children')
+
+    def __init__(self, *args, **kwargs):
+        self.fields['children'] = InlineQuestionnaireChildSerializer(many=True, required=True, context=kwargs['context'], partial=False)
+        super().__init__(*args, **kwargs)
+
+    def validate(self, data):
+        data = super().validate(data)
+        event = self.context['event']
+
+        #full_data = self.to_internal_value(self.to_representation(self.instance)) if self.instance else {}
+        #full_data.update(data)
+
+        #if full_data.get('ask_during_checkin') and full_data.get('dependency_question'):
+        #    raise ValidationError('Dependencies are not supported during check-in.')
+
+        #if full_data.get('ask_during_checkin') and full_data.get('type') in Question.ASK_DURING_CHECKIN_UNSUPPORTED:
+        #    raise ValidationError(_('This type of question cannot be asked during check-in.'))
+
+        #if full_data.get('show_during_checkin') and full_data.get('type') in Question.SHOW_DURING_CHECKIN_UNSUPPORTED:
+        #    raise ValidationError(_('This type of question cannot be shown during check-in.'))
+
+        #Question.clean_items(event, full_data.get('items') or [])
+        return data
+
+    def validate_children(self, value):
+        prev_questions = {}
+        for child in value:
+            if child.get('dependency_question'):
+                if (child['dependency_question']['user_question'] or child['dependency_question']['system_question']) not in prev_questions:
+                    raise ValidationError('A question can only depend on a previous question from the same questionnaire.')
+
+            if child['user_question']:
+                prev_questions[child['user_question']] = child
+            if child['system_question']:
+                prev_questions[child['system_question']] = child
+        return value
+
+    @transaction.atomic
+    def create(self, validated_data):
+        children_data = validated_data.pop('children') if 'children' in validated_data else []
+        questionnaire = super().create(validated_data)
+        self.set_children(questionnaire, children_data)
+        return questionnaire
+
+    @transaction.atomic
+    def update(self, instance, validated_data):
+        children_data = validated_data.pop('children', None)
+        questionnaire = super().update(instance, validated_data)
+        if children_data is not None:
+            self.set_children(questionnaire, children_data)
+        return questionnaire
+
+    def set_children(self, questionnaire, new_data):
+        result = []
+        child_serializer = self.fields['children'].child
+        existing = questionnaire.children.all()
+        for i, d in enumerate(new_data):
+            d['questionnaire'] = questionnaire
+            d['position'] = i + 1
+            d.setdefault('required', False)
+            d.setdefault('help_text', None)
+            d.setdefault('dependency_question', None)
+            d.setdefault('dependency_values', None)
+        updatable = min(len(existing), len(new_data))
+        for i in range(0, updatable):
+            result.append(child_serializer.update(existing[i], new_data[i]))
+        for i in range(updatable, len(new_data)):
+            result.append(child_serializer.create(new_data[i]))
+        for i in range(updatable, len(existing)):
+            existing[i].delete()
+        return result
+
+
 class QuotaSerializer(I18nAwareModelSerializer):
     available = serializers.BooleanField(read_only=True)
     available_number = serializers.IntegerField(read_only=True)

src/pretix/api/urls.py

@@ -79,7 +79,8 @@ event_router.register(r'subevents', event.SubEventViewSet)
 event_router.register(r'clone', event.CloneEventViewSet)
 event_router.register(r'items', item.ItemViewSet)
 event_router.register(r'categories', item.ItemCategoryViewSet)
-event_router.register(r'questions', item.QuestionViewSet)
+event_router.register(r'datafields', item.QuestionViewSet)
+event_router.register(r'questionnaires', item.QuestionnaireViewSet)
 event_router.register(r'discounts', discount.DiscountViewSet)
 event_router.register(r'quotas', item.QuotaViewSet)
 event_router.register(r'vouchers', voucher.VoucherViewSet)

src/pretix/api/views/item.py

@@ -47,13 +47,14 @@ from pretix.api.pagination import TotalOrderingFilter
 from pretix.api.serializers.item import (
     ItemAddOnSerializer, ItemBundleSerializer, ItemCategorySerializer,
     ItemProgramTimeSerializer, ItemSerializer, ItemVariationSerializer,
-    QuestionOptionSerializer, QuestionSerializer, QuotaSerializer,
+    QuestionOptionSerializer, QuestionSerializer, QuestionnaireSerializer, QuotaSerializer,
 )
 from pretix.api.views import ConditionalListView
 from pretix.base.models import (
     CartPosition, Item, ItemAddOn, ItemBundle, ItemCategory, ItemProgramTime,
     ItemVariation, Question, QuestionOption, Quota,
 )
+from pretix.base.models.items import Questionnaire
 from pretix.base.services.quotas import QuotaAvailability
 from pretix.helpers.dicts import merge_dicts
 from pretix.helpers.i18n import i18ncomp
@@ -538,6 +539,51 @@ class QuestionOptionViewSet(viewsets.ModelViewSet):
         super().perform_destroy(instance)
 
 
+class QuestionnaireViewSet(ConditionalListView, viewsets.ModelViewSet):
+    serializer_class = QuestionnaireSerializer
+    queryset = Questionnaire.objects.none()
+    #filter_backends = (DjangoFilterBackend, TotalOrderingFilter)
+    #filterset_class = QuestionFilter
+    ordering_fields = ('id', 'position')
+    ordering = ('position', 'id')
+    permission = None
+    write_permission = 'event.items:write'
+
+    def get_queryset(self):
+        return self.request.event.questionnaires.prefetch_related('children').all()
+
+    def perform_create(self, serializer):
+        serializer.save(event=self.request.event)
+        serializer.instance.log_action(
+            'pretix.event.questionnaire.added',
+            user=self.request.user,
+            auth=self.request.auth,
+            data=self.request.data
+        )
+
+    def get_serializer_context(self):
+        ctx = super().get_serializer_context()
+        ctx['event'] = self.request.event
+        return ctx
+
+    def perform_update(self, serializer):
+        serializer.save(event=self.request.event)
+        serializer.instance.log_action(
+            'pretix.event.questionnaire.changed',
+            user=self.request.user,
+            auth=self.request.auth,
+            data=self.request.data
+        )
+
+    def perform_destroy(self, instance):
+        instance.log_action(
+            'pretix.event.questionnaire.deleted',
+            user=self.request.user,
+            auth=self.request.auth,
+        )
+        super().perform_destroy(instance)
+
+
 class NumberInFilter(django_filters.BaseInFilter, django_filters.NumberFilter):
     pass