feat(program_v2): accept program offer

Author: japsu

backend/core/utils/model_utils.py

@@ -1,5 +1,6 @@
 import re
-from typing import Literal
+from collections.abc import Callable, Iterable
+from typing import Any, Literal
 
 import phonenumbers
 from django.conf import settings
@@ -36,19 +37,15 @@ def make_slug_field(
     unique=True,
     separator: Literal["-", "_"] = "-",
     verbose_name: str | None = None,
-    help_text: str | None = None,
+    help_text: str = "",
+    extra_validators: Iterable[Callable[[Any], None]] | None = None,
 ):
     if verbose_name is None:
-        verbose_name = _("Slug")
+        verbose_name = "Slug"
 
-    if help_text is None:
-        help_text = _(
-            "The slug is a URL-friendly identifier. "
-            "It may only contain lowercase letters, numbers, and hyphens. "
-            "It may not be changed after creation."
-        )
-
-    validators = [validate_slug] if separator == "-" else [validate_slug_underscore]
+    validators: list[Callable[[Any], None]] = [validate_slug] if separator == "-" else [validate_slug_underscore]
+    if extra_validators is not None:
+        validators.extend(extra_validators)
 
     return models.CharField(
         max_length=255,

backend/dimensions/models/dimension.py

@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING
 
 from django.contrib import admin
+from django.core.exceptions import ValidationError
 from django.db import models
 from django.http import HttpRequest
 from django.utils.translation import get_language
@@ -25,6 +26,28 @@
 logger = logging.getLogger("kompassi")
 
 
+INVALID_DIMENSION_SLUGS = [
+    # clash with field names in Program
+    "slug",
+    "title",
+    "description",
+    "annotations",
+    # clash with query string parameters for ProgramFilters
+    "favorited",
+    "past",
+    "display",
+    "search",
+]
+
+
+def invalid_slugs_validator(value: str) -> None:
+    """
+    Validator for dimension slugs. Raises a ValidationError if the slug is invalid.
+    """
+    if value in INVALID_DIMENSION_SLUGS:
+        raise ValidationError(f"{value!r} is a reserved word that cannot be used as a dimension slug.")
+
+
 class Dimension(models.Model):
     """
     Dimensions are "multiple choice fields on steroids" that can be used to
@@ -81,7 +104,7 @@ class Dimension(models.Model):
         ),
     )
 
-    slug = make_slug_field(unique=False, separator="_")
+    slug = make_slug_field(unique=False, separator="_", extra_validators=[invalid_slugs_validator])
 
     # NOTE SUPPORTED_LANGUAGES
     title_en = models.TextField(blank=True, default="")

backend/dimensions/utils/__init__.py

@@ -0,0 +1,37 @@
+from forms.models.field import Field, FieldType
+from forms.utils.process_form_data import process_form_data
+
+from ..models.dimension import Dimension
+
+
+def process_dimensions_form(
+    dimensions: list[Dimension],
+    form_data: dict[str, str],
+) -> dict[str, list[str]]:
+    """
+    When values for dimensions are selected using a SchemaForm, this function processes the form data
+    and returns the values for each dimension.
+
+    Args:
+        dimensions: A list of Dimension objects to process.
+        form_data: A dictionary of form data to process.
+
+    Returns:
+        A dictionary containing the value slugs for each dimension present in dimensions.
+    """
+    fields_single = [Field.from_dimension(dimension, FieldType.SINGLE_SELECT) for dimension in dimensions]
+    fields_multi = [Field.from_dimension(dimension, FieldType.MULTI_SELECT) for dimension in dimensions]
+
+    values_single, warnings_single = process_form_data(fields_single, form_data)
+    if warnings_single:
+        raise ValueError(warnings_single)
+
+    values_multi, warnings_multi = process_form_data(fields_multi, form_data)
+    if warnings_multi:
+        raise ValueError(warnings_multi)
+
+    values: dict[str, list[str]] = {k: [v] for k, v in values_single.items() if v}
+    for k, v in values_multi.items():
+        values.setdefault(k, []).extend(v)
+
+    return values

backend/dimensions/utils/process_dimensions_form.py

@@ -2,10 +2,9 @@
 from graphene.types.generic import GenericScalar
 
 from access.cbac import graphql_check_instance
+from dimensions.utils.process_dimensions_form import process_dimensions_form
 
-from ...models.field import Field, FieldType
 from ...models.survey import Survey
-from ...utils.process_form_data import process_form_data
 from ..response import FullResponseType
 
 
@@ -49,21 +48,7 @@ def mutate(
             operation="update",
         )
 
-        fields_single = [Field.from_dimension(dimension, FieldType.SINGLE_SELECT) for dimension in dimensions]
-        fields_multi = [Field.from_dimension(dimension, FieldType.MULTI_SELECT) for dimension in dimensions]
-
-        values_single, warnings_single = process_form_data(fields_single, form_data)
-        if warnings_single:
-            raise ValueError(warnings_single)
-
-        values_multi, warnings_multi = process_form_data(fields_multi, form_data)
-        if warnings_multi:
-            raise ValueError(warnings_multi)
-
-        values: dict[str, list[str]] = {k: [v] for k, v in values_single.items() if v}
-        for k, v in values_multi.items():
-            values.setdefault(k, []).extend(v)
-
+        values = process_dimensions_form(dimensions, form_data)
         response.set_dimension_values(values)
 
         return UpdateResponseDimensions(response=response)  # type: ignore

backend/forms/graphql/mutations/update_response_dimensions.py

@@ -22,6 +22,7 @@
 from forms.graphql.mutations.update_form_fields import UpdateFormFields
 from forms.graphql.mutations.update_response_dimensions import UpdateResponseDimensions
 from forms.graphql.mutations.update_survey import UpdateSurvey
+from program_v2.graphql.mutations.accept_program_offer import AcceptProgramOffer
 from program_v2.graphql.mutations.create_program_form import CreateProgramForm
 from program_v2.graphql.mutations.favorites import (
     MarkProgramAsFavorite,
@@ -126,6 +127,7 @@ class Mutation(graphene.ObjectType):
     create_program_form = CreateProgramForm.Field()
     update_program_form = UpdateProgramForm.Field()
 
+    accept_program_offer = AcceptProgramOffer.Field()
     update_program = UpdateProgram.Field()
 
     # Tickets v2

backend/graphql_api/schema.py

@@ -0,0 +1,91 @@
+import graphene
+from django.db import transaction
+from graphene.types.generic import GenericScalar
+
+from access.cbac import graphql_check_instance, graphql_check_model
+from core.models.event import Event
+from dimensions.utils.process_dimensions_form import process_dimensions_form
+from forms.models.field import Field, FieldType
+from forms.models.response import Response
+from forms.utils.process_form_data import process_form_data
+
+from ...models.program import Program
+from ..program_full import FullProgramType
+
+# TODO supply system forms to the frontend from the backend
+ACCEPT_PROGRAM_FORM_FIELDS = [
+    Field(
+        slug="slug",
+        type=FieldType.SINGLE_LINE_TEXT,
+        required=True,
+    ),
+    Field(
+        slug="title",
+        type=FieldType.SINGLE_LINE_TEXT,
+        required=False,
+    ),
+    # dimensions are added dynamically
+]
+
+
+class AcceptProgramOfferInput(graphene.InputObjectType):
+    event_slug = graphene.String(required=True)
+    response_id = graphene.UUID(required=True)
+    form_data = GenericScalar(required=True)
+
+
+class AcceptProgramOffer(graphene.Mutation):
+    class Arguments:
+        input = AcceptProgramOfferInput(required=True)
+
+    program = graphene.NonNull(FullProgramType)
+
+    @transaction.atomic
+    @staticmethod
+    def mutate(_root, info, input: AcceptProgramOfferInput):
+        """
+        Turns a program offer into a program.
+        """
+        form_data: dict[str, str] = input.form_data  # type: ignore
+
+        program_offer = Response.objects.get(
+            id=input.response_id,
+            form__event__slug=input.event_slug,
+            form__survey__app="program_v2",
+        )
+        event: Event = program_offer.form.event  # ugh
+
+        # check that we are both allowed to read the program offer and create a program
+        graphql_check_instance(
+            program_offer,
+            info,
+            app="program_v2",
+        )
+        graphql_check_model(
+            Program,
+            event.scope,
+            info,
+            operation="create",
+        )
+
+        # NOTE form_data is the form sent when accepting the program offer
+        # and not the form sent when creating the program offer
+        values, warnings = process_form_data(ACCEPT_PROGRAM_FORM_FIELDS, form_data)
+        if warnings:
+            raise ValueError(warnings)
+
+        dimension_values = process_dimensions_form(
+            list(event.program_universe.dimensions.all()),
+            form_data,
+        )
+        program_offer.set_dimension_values(dimension_values)
+
+        program = Program.from_program_offer(
+            program_offer,
+            slug=values["slug"],
+            title=values.get("title", ""),
+        )
+        program.set_dimension_values(dimension_values)
+        program.refresh_cached_fields()
+
+        return AcceptProgramOffer(program=program)  # type: ignore

backend/program_v2/graphql/mutations/accept_program_offer.py

@@ -4,8 +4,6 @@
 
 from pydantic import BaseModel, Field
 
-# from programme.models.programme import Programme
-
 
 class AnnotationDataType(Enum):
     STRING = "string"
@@ -224,3 +222,18 @@ class ProgramAnnotation(BaseModel):
         ),
     ),
 ]
+
+
+def extract_annotations(values: dict[str, Any], annotations=ANNOTATIONS) -> dict[str, Any]:
+    """
+    Extract known annotations from processed form data.
+
+    Args:
+        values: A dictionary of values to extract annotations from.
+        annotations: A list of AnnotationSchemoid objects to use for extraction.
+
+    Returns:
+        A dictionary containing the extracted annotations.
+    """
+    # TODO typecheck against ann.type
+    return {ann.slug: value for ann in annotations if (value := values.get(ann.slug)) is not None}

backend/program_v2/models/annotations.py

@@ -12,10 +12,13 @@
 from django.utils.timezone import now
 
 from core.models import Event
-from core.utils import validate_slug
+from core.utils.model_utils import slugify, validate_slug
 from dimensions.models.scope import Scope
+from forms.models.response import Response
 from graphql_api.language import SUPPORTED_LANGUAGES, getattr_message_in_language
 
+from .annotations import extract_annotations
+
 if TYPE_CHECKING:
     from programme.models.programme import Programme
 
@@ -41,7 +44,7 @@ class Program(models.Model):
     updated_at = models.DateTimeField(auto_now=True)
 
     # denormalized fields
-    cached_dimensions = models.JSONField(default=dict)
+    cached_dimensions = models.JSONField(default=dict, blank=True)
     cached_earliest_start_time = models.DateTimeField(
         null=True,
         blank=True,
@@ -308,3 +311,40 @@ def set_dimension_values(self, values_to_set: dict[str, list[str]]):
 
         bulk_delete.delete()
         ProgramDimensionValue.objects.bulk_create(bulk_create)
+
+    @classmethod
+    def from_program_offer(
+        cls,
+        program_offer: Response,
+        slug: str = "",
+        title: str = "",
+    ) -> Self:
+        """
+        Return an unsaved Program instance from a program offer.
+        """
+        values, warnings = program_offer.get_processed_form_data()
+        if warnings:
+            logger.warning("Program offer %s had form data warnings: %s", program_offer.id, warnings)
+
+        annotations = extract_annotations(values)
+
+        if not title:
+            title = values.get("title", "")
+
+        if not slug:
+            slug = slugify(title)
+
+        program = cls(
+            event=program_offer.event,
+            slug=slug,
+            title=title,
+            description=values.get("description", ""),
+            annotations=annotations,
+            created_by=program_offer.created_by,
+            cached_dimensions={},
+        )
+
+        program.full_clean()
+        program.save()
+
+        return program