from wagtail.blocks import StreamValue
from wagtail.blocks.list_block import ListBlock, ListValue
from wagtail.rich_text import RichText

from vbv_lernwelt.assignment.models import (
    AssignmentListPage,
    AssignmentType,
    EvaluationSubTaskBlock,
    TaskContentStreamBlock,
)
from vbv_lernwelt.assignment.tests.assignment_factories import (
    AssignmentFactory,
    EvaluationSubTaskBlockFactory,
    EvaluationTaskBlockFactory,
    ExplanationBlockFactory,
    PerformanceObjectiveBlockFactory,
    TaskBlockFactory,
    UserTextInputBlockFactory,
)
from vbv_lernwelt.core.utils import replace_whitespace
from vbv_lernwelt.course.consts import (
    COURSE_UK,
    COURSE_UK_FR,
    COURSE_VERSICHERUNGSVERMITTLERIN_ID,
)
from vbv_lernwelt.course.models import CoursePage
from vbv_lernwelt.media_files.models import ContentDocument


def create_uk_fahrzeug_casework(
    course_id=COURSE_UK, competence_certificate=None, with_documents=False
):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Überprüfen einer Motorfahrzeugs-Versicherungspolice",
        needs_expert_evaluation=True,
        competence_certificate=competence_certificate,
        effort_required="ca. 5 Stunden",
        intro_text=replace_whitespace(
            """
        <h3>Ausgangslage</h3>
        <p>
        Jemand aus deiner Familie oder aus deinem Freundeskreis möchte sein
        Versicherungspolice überprüfen lassen. Diese Person kommt nun mit ihrer Police auf dich zu
        und bittet dich als Versicherungsprofi, diese kritisch zu überprüfen und ihr ggf. Anpassungsvorschläge
        zu unterbreiten. In diesem Kompetenznachweis kannst du nun dein Wissen und Können im Bereich
        der Motorfahrzeugversicherung unter Beweis stellen.
        </p>
        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Sie erläutern die Leistungen und Produkte im Versicherungsbereich."
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Sie beurteilen gängige Versicherungslösungen fachkundig."
                ),
            ),
        ],
        evaluation_document_url="/static/media/assignments/UK_03_09_NACH_KN_Beurteilungsraster.pdf",
        evaluation_description="Diese geleitete Fallarbeit wird auf Grund des folgenden Beurteilungsintrument bewertet.",
    )
    if with_documents:
        assignment.solution_sample = ContentDocument.objects.get(
            title="Musterlösung Fahrzeug"
        )
        assignment.save()

    assignment.evaluation_tasks = []
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Ausgangslage des Auftrags",
                description=RichText(
                    "Beschreibt der/die Lernende die Ausgangslage des Auftrags vollständig?"
                ),
                max_points=6,
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Die Ausgangslage des Auftrag ist vollständig beschrieben.",
                            description=RichText(
                                replace_whitespace(
                                    """
                                    <ul>
                                    <li>Worum geht es? Was ist die Aufgabe?</li>
                                    <li>Sind das Kundenprofil und die Kundenbeziehung vollständig und nachvollziehbar dargestellt?</li>
                                    <li>Ist das Alter des Fahrzeugs dokumentiert?</li>
                                    <li>Welche Ressourcen stehen zur Verfügung?</li>
                                    </ul>
                                    """
                                )
                            ),
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Ausgangslage ist grösstenteils vollständig beschrieben.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Ausgangslage ist unvollständig - nur 2 Punkte wurden beschrieben.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Ausgangslage des Auftrag ist unvollständig - es fehlen mehr als 2 Punkte in der Beschreibung.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Inhaltsanalyse und Struktur",
                max_points=6,
                description=RichText(
                    "Sind die Deckungen der Police vollständig und nachvollziehbar dokumentiert?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Die Analyse beinhaltet alle in der Police vorhandenen Deckungen und ist logisch aufgebaut.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Analyse beinhaltet die meisten vorhandenen Deckungen in der Police und ist grösstenteils logisch aufgebaut.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Analyse ist unvollständig (es fehlen mehr als 3 Deckungen) und der rote Faden ist nicht erkennbar.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Analyse ist insgesamt nicht nachvollziehbar und es fehlen einige Deckungen.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Sinnvolle Empfehlungen",
                max_points=6,
                description=RichText(
                    "Leitet die lernende Person sinnvolle und geeignete Empfehlungen ab?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Die Empfehlungen sind durchgängig sinnvoll und nachvollziehbar begründet.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Empfehlungen sind grösstenteils sinnvoll und nachvollziehbar begründet.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Empfehlungen sind wenig sinnvoll und unvollständig begründet.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Empfehlungen sind weder sinnvoll nch nachvollziehbar begründet.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Qualität der Reflexion",
                max_points=3,
                description=RichText(
                    "Reflektiert die lernende Person die Durchführung der geleiteten Fallarbeit?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Die Reflexion bezieht sich auf die geleitete Fallarbeit und umfasst nachvollziehbare positive wie negative Aspekte.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Reflexion bezieht sich auf die geleitete Fallarbeit und umfasst grösstenteils nachvollziehbare positive wie negative Aspekte.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Reflexion ist unvollständig.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Reflexion bezieht sich nicht auf die geleitete Fallarbeit.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Eignung der Learnings",
                max_points=3,
                description=RichText(
                    "Leitet die lernende Person geeignete Learnings aus der Reflexion ab?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Die Learnings beziehen sich auf die geleitete Fallarbeit und sind inhaltlich sinnvoll.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Learnings beziehen sich grösstenteils auf die geleitete Fallarbeit und sind inhaltlich sinnvoll.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Learnings beziehen sich teilweise auf die geleitete Fallarbeit und sind inhaltlich wenig sinnvoll.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Die Learnings beziehen sich nicht auf die geleitete Fallarbeit.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Beispiel einer Versicherungspolice finden",
                file_submission_required=True,
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Bitte jemand aus deiner Familie oder deinem Freundeskreis darum, dir seine/ihre Motorfahrzeugversicherungspolice zur Verfügung zu stellen."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ja, ich habe Motorfahrzeugversicherungspolice von jemandem aus meiner Familie oder meinem Freundeskreis erhalten."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Kundensituation und Ausgangslage",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Erläutere die Kundensituation und die Ausgangslage.
                                        <ul>
                                        <li>Hast du alle Informationen, die du für den Policen-Check benötigst?</li>
                                        <li>Halte die wichtigsten Eckwerte des aktuellen Versicherungsverhältnisse in deiner Dokumentation fest (z.B wie lang wo versichert, Alter des Fahrzeugs, Kundenprofil, etc.</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Aktuelle Versicherung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Zeige nun detailliert auf, wie dein Kundenbeispiel momentan versichert ist."
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Deine Empfehlungen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Erarbeite nun basierend auf deinen Erkenntnissen eine Empfehlung für die Person."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Gibt es zusätzliche Deckungen, die du der Person empfehlen würdest? Begründe deine Empfehlung"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Gibt es Deckungen, die du streichen würdest? Begründe deine Empfehlung."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wenn die Person gemäss deiner Einschätzung genau richtig versichert ist, argumentiere, warum dies der Fall ist."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 5: Reflexion",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Reflektiere dein Handeln und halte deine Erkenntnisse fest. Frage dich dabei:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "War die Bearbeitung dieser geleiteten Fallarbeit erfolgreich? Begründe deine Einschätzung."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was ist dir bei der Bearbeitung des Auftrags gut gelungen?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was ist dir bei der Bearbeitung des Auftrags weniger gut gelungen?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 6: Learnings",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Leite aus der Teilaufgabe 5 deine persönlichen Learnings ab."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was würdest du beim nächsten Mal anders machen?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was hast du beim Bearbeiten des Auftrags Neues gelernt?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_fr_fahrzeug_casework(course_id=COURSE_UK_FR):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Vérification d'une police d’assurance de véhicule à moteur",
        effort_required="5 heures environ",
        intro_text=replace_whitespace(
            """
        <h3>Exposé de la situation</h3>
        <p>
        Une personne de ta famille ou de tes connaissances souhaite faire vérifier sa police d'assurance. Elle se
        tourne alors vers toi et te demande, en ta qualité de spécialiste de l'assurance, de l'examiner d’un œil
        critique et de lui soumettre, le cas échéant, des propositions d'adaptation. Dans le cadre de cette évaluation
        des compétences, tu peux maintenant prouver tes connaissances et tes compétences dans le domaine de l'assurance
        des véhicules à moteur.
        </p>
        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="d2.pv.ük3: Ils expliquent les services et les produits dans le domaine de l’assurance."
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="c3.pv.ük11: Ils évaluent les solutions d’assurance courantes avec professionnalisme (C3)."
                ),
            ),
        ],
        evaluation_document_url="/static/media/assignments/fr_üK1_FZ_09_NACH_KN_Beurteilungsraster.pdf",
        evaluation_description="Diese geleitete Fallarbeit wird auf Grund des folgenden Beurteilungsintrument bewertet.",
    )

    assignment.evaluation_tasks = []
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Exposé de la situation de départ",
                description=RichText(
                    "L'apprenant(e) expose-t-il / elle la situation de départ dans son intégralité?"
                ),
                max_points=6,
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="La situation de départ est décrite dans son intégralité:",
                            description=RichText(
                                replace_whitespace(
                                    """
                                    <ul>
                                    <li>De quoi s’agit-il? En quoi consiste l’exercice?</li>
                                    <li>Le profil du client et la relation avec le client sont-ils présentés de manière exhaustive et compréhensible?</li>
                                    <li>L'âge du véhicule est-il documenté</li>
                                    <li>Quelles sont les ressources à disposition?</li>
                                    </ul>
                                    """
                                )
                            ),
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La situation de départ est en grande partie décrite dans son intégralité.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La description de la situation de départ est incomplète - seuls 2 points ont été exposés.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La description de la situation de départ est incomplète - il manque plus de 2 points importants.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Analyse de contenu et structure",
                max_points=6,
                description=RichText(
                    "Les couvertures de la police sont-elles documentées de manière exhaustive et compréhensible?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="L'analyse comprend toutes les couvertures présentes dans la police et est structurée de manière logique.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="L'analyse comprend la plupart des couvertures existantes dans la police et est en grande partie structurée de manière logique.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="L'analyse est incomplète (il manque plus de 3 couvertures), et le fil conducteur n'est pas clair.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Dans l'ensemble, l'analyse n'est pas compréhensible, et il manque certaines couvertures.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Recommandations judicieuses",
                max_points=6,
                description=RichText(
                    "La personne apprenante en déduit-elle des recommandations pertinentes et appropriées?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Les recommandations sont toujours pertinentes et argumentées de manière compréhensible.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les recommandations sont pour la plupart pertinentes et argumentées de manière compréhensible.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les recommandations manquent de pertinence et ne sont pas entièrement étayées par une argumentation.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les recommandations ne sont ni pertinentes ni argumentées de manière compréhensible.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Qualité de la réflexion",
                max_points=3,
                description=RichText(
                    "La personne apprenante reproduit-elle le déroulement de l’étude de cas dirigée?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="La réflexion porte sur l’étude de cas dirigée et comprend des aspects positifs et négatifs compréhensibles.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La réflexion porte sur l’étude de cas dirigée et comprend en grande partie des aspects positifs et négatifs compréhensibles.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La réflexion est incomplète.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La réflexion ne porte pas sur l’étude de cas dirigée.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Adéquation des connaissances acquises",
                max_points=3,
                description=RichText(
                    "La personne apprenante tire-t-elle des connaissances appropriées de la réflexion?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Les connaissances acquises se rapportent à l’étude de cas dirigée, et leur contenu est pertinent.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les connaissances acquises se rapportent en grande partie à l’étude de cas dirigée, et leur contenu est pertinent.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les connaissances acquises se rapportent en partie à l’étude de cas dirigée, et leur contenu manque de pertinence.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Les connaissances acquises ne portent pas sur l’étude de cas dirigée.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 1: Trouver un exemple de police d'assurance",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Demande à quelqu'un de ta famille ou de tes connaissances de te fournir sa police d'assurance automobile."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Oui, j'ai reçu une police d'assurance automobile de quelqu'un de ma famille ou de mon cercle d'amis."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 2: Situation du client et position de départ",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Explique la situation du client et le contexte de départ.
                                        <ul>
                                        <li>Disposes-tu de toutes les informations dont tu as besoin pour l'examen de la police?</li>
                                        <li>Note dans ta documentation les principales valeurs de référence de la relation d'assurance actuelle (par ex. durée de l’assurance, nom de l’assureur, âge du véhicule, profil du client, etc.).</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 3: Assurance en cours",
                # TODO: add document upload
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Expose maintenant dans le détail comment le client de ton exemple est assuré pour le moment."
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 4: Tes recommandations",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Sur la base de ce que tu as observé, formule maintenant une recommandation."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Recommanderais-tu la souscription de couvertures supplémentaires? Argumente ta recommandation."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "    Supprimerais-tu certaines couvertures? Argumente ta recommandation."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Si tu estimes que la personne est assurée exactement comme il faut, précise pour quelles raisons tu arrives à cette conclusion."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 5: Réflexion",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Réfléchis à ton comportement et consigne tes conclusions. Pose-toi les questions suivantes:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "As-tu traité correctement cette étude de cas dirigée? Justifie ton sentiment."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Qu’est-ce que tu as réussi à bien traiter dans cette étude de cas?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Qu’est-ce que tu as moins bien réussi à traiter dans cette étude de cas?"
                                )
                            ),
                        ),
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Note tes conclusions dans la documentation et télécharge-la ensuite sur la plateforme d’apprentissage pour l’évaluation."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 6: Apprentissages",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "En t’appuyant sur l’exercice n°5, dresse le bilan de ce que tu as appris."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Qu’est-ce que tu ferais différemment la prochaine fois?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Qu’as-tu appris de nouveau en traitant cette étude de cas?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 7: Apprentissages",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Rédige une documentation compréhensible et logique et transmets-la dans les délais."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_it_fahrzeug_casework(course_id=COURSE_UK_FR):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Verifica di una polizza di assicurazione veicoli a motore",
        effort_required="Circa 3 ore",
        intro_text=replace_whitespace(
            """
        <h3>Situazione di partenza</h3>
        <p>Un tuo amico/una tua amica o un tuo/una tua familiare vorrebbe sottoporre a verifica la propria polizza
        assicurativa. Sapendo che conosci bene il ramo assicurativo, te la mostra chiedendoti di verificarla con sguardo
        critico e di proporre eventualmente qualche modifica. In questo compito di controllo delle competenze puoi dare
        prova delle tue conoscenze e capacità nel settore dell’assicurazione veicoli a motore.
        </p>
        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="d2.pv.ci3: Illustrare le prestazioni e i prodotti nel settore assicurativo. (C2)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="c3.pv.ci11: Valutare con competenza le soluzioni assicurative più comuni (C3)."
                ),
            ),
        ],
        evaluation_document_url="/static/media/assignments/it_üK1_FZ_09_NACH_KN_Beurteilungsraster.pdf",
        evaluation_description="Strumento di valutazione del caso di studio guidato: «Verifica di una polizza di assicurazione veicoli a motore»",
    )

    assignment.evaluation_tasks = []
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Situazione di partenza dell’incarico",
                description=RichText(
                    "L’apprendista ha descritto in modo completo la situazione di partenza dell’incarico?"
                ),
                max_points=6,
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="La situazione di partenza dell’incarico è stata descritta in modo completo:",
                            description=RichText(
                                replace_whitespace(
                                    """
                                    <ul>
                                    <li>Di cosa si tratta? Qual è il compito?</li>
                                    <li>Il profilo del/della cliente e il rapporto con il/la cliente sono stati illustrati in modo chiaro e completo?</li>
                                    <li>L’età del veicolo è stata documentata?</li>
                                    <li>Quali sono le risorse a disposizione?</li>
                                    </ul>
                                    """
                                )
                            ),
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La situazione di partenza è stata descritta in larga misura in modo completo.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La situazione di partenza è incompleta: sono stati descritti solo due punti.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La situazione di partenza dell’incarico è incompleta: nella descrizione mancano più di due punti.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Analisi contenutistica e struttura",
                max_points=6,
                description=RichText(
                    "Le coperture della polizza sono state documentate in modo chiaro e completo?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="L’analisi contiene tutte le coperture presenti nella polizza ed è ben strutturata.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="L’analisi contiene la maggior parte delle coperture presenti nella polizza ed è in larga misura ben strutturata.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="L’analisi è incompleta (mancano più di tre coperture) e non emerge un filo conduttore.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Nel complesso l’analisi non è chiara e mancano alcune coperture.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Raccomandazioni utili",
                max_points=6,
                description=RichText(
                    "L’apprendista ha ricavato raccomandazioni utili e appropriate?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Le raccomandazioni sono utili e motivate con chiarezza.",
                            points=6,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Le raccomandazioni sono in larga misura utili e motivate con chiarezza.",
                            points=4,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Le raccomandazioni non sono di grande utilità e sono motivate in modo incompleto.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Le raccomandazioni non sono né utili né motivate con chiarezza.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Qualità della riflessione",
                max_points=3,
                description=RichText(
                    "L’apprendista ha riflettuto sullo svolgimento dell’analisi guidata del caso?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="La riflessione si riferisce all’analisi guidata del caso e include aspetti positivi e negativi illustrati con chiarezza.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La riflessione si riferisce all’analisi guidata del caso e include in larga misura aspetti positivi e negativi illustrati con chiarezza.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La riflessione è incompleta.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="La riflessione non si riferisce al caso di studio guidato.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="doneità degli insegnamenti",
                max_points=3,
                description=RichText(
                    "L’apprendista ha tratto insegnamenti idonei dalla riflessione?"
                ),
                sub_tasks=ListValue(
                    ListBlock(EvaluationSubTaskBlock()),
                    values=[
                        EvaluationSubTaskBlockFactory(
                            title="Gli insegnamenti si riferiscono al caso di studio guidato e si rivelano utili.",
                            points=3,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Gli insegnamenti si riferiscono in larga misura al caso di studio guidato e si rivelano utili.",
                            points=2,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Gli insegnamenti si riferiscono solo in parte all’analisi guidata del caso e non si rivelano molto utili.",
                            points=1,
                        ),
                        EvaluationSubTaskBlockFactory(
                            title="Gli insegnamenti non si riferiscono al caso di studio guidato.",
                            points=0,
                        ),
                    ],
                ),
            ),
        ),
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 1: Trovare un’esempio di una polizza assicurativa",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Chiedi a un amico/un’amica o a un/una familiare di fornirti la sua polizza di assicurazione veicoli a motore."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Sì, ho ricevuto una polizza assicurativa auto da qualcuno della mia famiglia o cerchia di amici."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 2: Situazione del cliente e situazione iniziale",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Illustra il caso del/della cliente e la situazione iniziale.
                                        <ul>
                                        <li>Disponi di tutte le informazioni che ti servono per effettuare la verifica della polizza?</li>
                                        <li>Annotati le informazioni principali riguardanti l’attuale rapporto assicurativo (ad es. da quanto tempo è assicurato il/la cliente e presso quale compagnia assicurativa, quanti anni ha il veicolo, qual è il profilo del/della cliente ecc.).</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 3: Assicurazione attuale",
                # TODO: add document upload
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Mostra ora in dettaglio l’attuale situazione assicurativa del tuo/della tua cliente."
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 4: Le tue raccomandazioni",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Sulla base delle informazioni raccolte, elabora ora una raccomandazione."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Consiglieresti al/alla cliente di stipulare coperture complementari? Motiva la tua raccomandazione."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Elimineresti qualche copertura?  Motiva la tua raccomandazione."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quando hai terminato il lavoro, spiega perché con la tua proposta il/la cliente beneficia di un’assicurazione ottimale."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 5: Riflessione",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Rifletti sul lavoro svolto e annotati le informazioni finora acquisite. Domandati:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Ho affrontato bene questo caso di studio guidato? Motiva la tua valutazione."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Cosa ha funzionato durante lo svolgimento di questo incarico?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Cosa non ha funzionato durante lo svolgimento di questo incarico?"
                                )
                            ),
                        ),
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Annotati tutte queste informazioni e caricale sulla piattaforma di apprendimento per sottoporle a valutazione."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 6: Apprendimenti",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Trai i tuoi insegnamenti personali dall’compito parziale 5"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Cosa cambieresti nel tuo approccio se potessi ripetere l’esperienza?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Cos’hai imparato di nuovo dall’elaborazione dell’incarico?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    # assignment.tasks.append(
    #     (
    #         "task",
    #         TaskBlockFactory(
    #             title="Compito parziale 7",
    #             content=StreamValue(
    #                 TaskContentStreamBlock(),
    #                 stream_data=[
    #                     (
    #                         "explanation",
    #                         ExplanationBlockFactory(
    #                             text=RichText(
    #                                 "Redigi un documento chiaro e ben strutturato e presentalo entro la scadenza."
    #                             )
    #                         ),
    #                     ),
    #                 ],
    #             ),
    #         ),
    #     )
    # )

    assignment.save()

    return assignment


def create_uk_fahrzeug_prep_assignment(course_id=COURSE_UK_FR):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Fahrzeug - Mein erstes Auto",
        effort_required="ca. 3 Stunden",
        intro_text=replace_whitespace(
            """
            <h3>Handlungskompetenzen, Arbeitssituationen & Leistungsziele</h3>
            <p>
            Handlungskompetenz d2: Informations- und Beratungsgespräch mit Kunden oder Lieferanten führen<br/>
            Arbeitssituation 4: Kunden beraten und dazugehörige Prozesse abwickeln<br/>
            <ul>
            <li>d2.pv.ük3: Sie erläutern die Leistungen und Produkte im Versicherungsbereich. (K2)</li>
            <li>d2pv.ük4: Sie erläutern die Prozesse und Abläufe im privaten Versicherungsbereich. (K2)</li>
            </ul>
            </p>

            <p>
            Handlungskompetenz e4: Betriebsbezogene Inhalte multimedial aufbereiten<br/>
            Arbeitssituation 1: Charakteristiken der Branche und Stärken des Betriebs einbringen<br/>
            <ul>
            <li>e4.pv.ük1: Sie erläutern die Dienstleistungen des Betriebs. (K2)</li>
            <li>e4.pv.ük2: Sie unterscheiden Mitbewerber in der privaten Versicherungsbranche anhand der relevanten Kriterien.(K2)</li>
            <li>e4.pv.ük4: Sie erläutern die Grundlagen der Produkte von Privatversicherungen. (K2)</li>
            </ul>
            </p>

            <h3>Ausgangslage</h3>
            <p>
            Stell dir vor, du hast die Autoprüfung abgeschlossen und nun kann es endlich losgehen mit deiner Mobilität.
            Welches wird dein erstes eigenes Auto sein? Dieses Auto möchtest du natürlich auch schützen und richtig
            versichern.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Verschaffe dir einen ersten Überblick zum Thema.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Schaue dazu das folgende Video: <a href="https://www.youtube.com/watch?v=GY2VRYyhwjM" target="_blank">Wie funktioniert eine Autoversicherung? – Einfach erklärt</a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ja, ich habe das Video angeschaut und verstanden."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Kapitel «Haftpflichtrecht und Motorfahrzeugversicherung» lesen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Lese und bearbeite im Buch «Haftpflichtrecht und Motorfahrzeugversicherung» die entsprechenden Kapitel"
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ja, ich habe das Kapitel gelesen und verstanden."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Offerte erstellen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Nun geht es los! Erstelle dir für dein erstes eigenes Auto eine entsprechende
                                        Offerte. Überlege dir, welche Deckungen du unbedingt abschliessen musst und
                                        welche Deckungen für dich zusätzlich wünschenswert sind. Nutze dazu das
                                        Offertentool deiner Unternehmung. Alternativ dazu kannst du auch irgendein
                                        Onlinetool nutzen.
                                        </p>
                                        <p>
                                        Möglicherweise musst du mit deinem Geburtsjahrgang etwas schummeln,
                                        damit du alt genug bist, um für dich eine Offerte zu machen.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe eine Offerte erstellt.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Notizen und Fragestellungen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Mache dir im Verlauf des Prozesses Notizen zu den folgenden Fragestellungen:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie bist du bei der Erstellung deiner Offerte vorgegangen?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welches waren die Schwierigkeiten bei der Erstellung der Offerte? Wie hast du die Schwierigkeiten gelöst?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche Angaben sind zwingend notwendig, um eine saubere Motorfahrzeugofferte erstellen zu können?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche zusätzlichen Deckungen hast du gewählt? Was waren die Überlegungen dazu?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche Faktoren/Elemente bestimmen hauptsächlich die Höhe der Prämie?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 5: Präzenz-Training",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "<p>Bringe die Offerte und diese Notizen mit ins Präsenz-Training.</p>"
                                    "<p>Vergiss die dazugehörenden AVB nicht. Es ist auch okay, wenn du die Unterlagen nur elektronisch dabei hast.</p>"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Aufgaben zum Vorbereitungsauftrag",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Schnappt euch euren Vorbereitungsauftrag und setzt euch zu dritt zusammen. Diskutiert miteinander die folgenden Fragen."
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie seid ihr bei der Erstellung der Offerte vorgegangen?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welches waren die Schwierigkeiten bei der Erstellung der Offerte? Wie hast du die Schwierigkeiten gelöst?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche Angaben sind zwingend notwendig, um eine saubere Motorfahrzeugofferte erstellen zu können?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche zusätzlichen Deckungen hast du gewählt? Was waren die Überlegungen dazu?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Welche Faktoren/Elemente bestimmen hauptsächlich die Höhe der Prämie?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wenn ihr mit der Diskussion und dem Vergleich fertig seid, schreibt doch die Prämie eurer eigenen Offerte jeweils auf den Flipchart/Whiteboard/Wandtafel."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_fr_fahrzeug_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Véhicule à moteur – «Ma première voiture»",
        effort_required="3 heures environ",
        intro_text=replace_whitespace(
            """
            <h3>Compétences opérationnelles, situations de travail et objectifs à atteindre</h3>
            <p>
            Compétence opérationnelle d2 : Mener des entretiens d’information et de conseil avec des
            clients et des fournisseurs<br/>
            Situation de travail 4 : Conseiller les clients et s’occuper des processus correspondants<br/>
            <ul>
            <li>d2.pv.ci3: Ils expliquent les services et les produits dans le domaine de l’assurance. (C2)</li>
            <li>d2pv.ci4: Ils expliquent les processus et procédures dans le domaine de l’assurance privée. (C2)</li>
            </ul>
            </p>

            <p>
            Compétence opérationnelle e4 : Préparer des contenus en lien avec l’entreprise à l’aide d’outils multimédia<br/>
            Situation de travail 1 : Mettre en avant les caractéristiques de la branche et les points forts de l’entreprise<br/>
            <ul>
            <li>e4.pv.ci1: Ils expliquent les services proposés par l’entreprise. (C2)</li>
            <li>e4.pv.ci2: Ils distinguent les concurrents sur le marché de l’assurance privée les uns des autres en utilisant les critères appropriés. (C2)</li>
            <li>e4.pv.ci4: Ils expliquent les principes sur lesquels reposent les produits des assurances privées. (C2) </li>
            </ul>
            </p>

            <h3>Exposé de la situation</h3>
            <p>
            Imagine que tu viens de réussir ton permis de conduire et que tu vas enfin pouvoir être davantage mobile.
            Quelle sera ta première voiture? Et cette voiture, tu vas évidemment vouloir la protéger et l’assurer correctement.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 1: Obtenez un premier aperçu du sujet.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Commence par te faire une première idée de ce sujet: regarde la vidéo suivante: <a href="https://www.youtube.com/watch?v=RLoIs1DBWSM" target="_blank">Comment fonctionne une assurance auto? Un sujet expliqué simplement?</a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Oui, j'ai regardé la vidéo et j'ai compris."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 2: Lire le chapitre «Droit de la responsabilité civile et assurances des véhicules à moteur»",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Lis et traite les chapitres correspondants dans le manuel «Droit de la responsabilité civile et assurances des véhicules à moteur»."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai lu et compris le chapitre.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 3: Établir une offre",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        C’est parti! Établis une offre correspondante pour ta première voiture. Réfléchis aux couvertures que tu souhaites absolument inclure et celles qui seraient souhaitables dans ton cas. À cet effet, utilise l’outil de ta compagnie pour l’établissement des offres. Tu peux aussi utiliser n'importe quel outil équivalent en ligne.
                                        </p>
                                        <p>
                                        Tu devras peut-être tricher un peu avec ton année de naissance pour être assez âgé(e) pour t’établir une offre.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai établi une offre.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 4: Notes et questions",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Au cours de ce processus, prends des notes pour répondre aux questions suivantes:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Comment as-tu procédé pour établir ton offre?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quelles difficultés as-tu rencontrées lors de l’établissement de l’offre? Comment as-tu résolu ces difficultés?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quelles informations sont indispensables pour pouvoir établir une offre correcte d’assurance des véhicules à moteur?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Pour quelles couvertures complémentaires as-tu opté? Pour quelles raisons?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quels sont les principaux facteurs / éléments qui déterminent le montant de la prime?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Exercice 5: Cours en présentiel",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "<p>Apporte l’offre et tes notes en cours.</p>"
                                    "<p>N'oublie pas les CGA correspondantes. Ce n’est pas un problème si tu n’as ces documents que sous forme électronique.</p>"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_it_fahrzeug_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Veicolo, la mia prima auto",
        effort_required="circa 3 ore",
        intro_text=replace_whitespace(
            """
            <h3>Competenze operative, situazioni di lavoro e obiettivi di valutazione</h3>
            <p>
            Competenza operativa d2: condurre colloqui informativi e di consulenza con la clientela o i fornitori<br/>
            Situazione di lavoro 4: fornire consulenza alla clientela e gestire i relativi processi<br/>
            <ul>
            <li>d2.pv.ci3: Illustrare le prestazioni e i prodotti nel settore assicurativo. (C2)</li>
            <lid2.pv.ci4: Illustrare i processi e le procedure nel settore delle assicurazioni private. (C2)</li>
            </ul>
            </p>

            <p>
            Competenza operativa e4: preparare a livello multimediale contenuti riferiti all’azienda<br/>
            Situazione di lavoro 1: integrare le caratteristiche del settore e i punti di forza dell’azienda<br/>
            <ul>
            <li>e4.pv.ci1: Illustrare i servizi dell’azienda. (C2)</li>
            <li>e4.pv.ci2: Distinguere i concorrenti nel ramo assicurativo privato sulla base di criteri rilevanti. (C2)</li>
            <li>e4.pv.ci4: Illustrare gli elementi di base dei prodotti delle assicurazioni private. (C2)</li>
            </ul>
            </p>

            <h3>Situazione di partenza</h3>
            <p>
            Fai finta di aver appena superato l’esame di guida e di poterti finalmente spostare in autonomia.
            Quale sarà la tua prima auto? Naturalmente vuoi anche proteggerla e assicurarla come si deve.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 1: Ottieni una panoramica iniziale dell'argomento",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Fatti una prima idea dell’argomento. Guarda il seguente video: <a href="https://www.youtube.com/watch?v=Z1icU7IZ7yI" target="_blank">Come funziona un’assicurazione auto? – I punti chiave</a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho visto il video e ho capito.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 2: Leggere il capitolo “Il diritto della responsabilità civile e L’assicurazione dei veicoli a motore”",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Leggi e studia i capitoli inerenti all’argomento nel libro Diritto della responsabilità civile e assicurazione veicoli a motore."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho letto e compreso il capitolo.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 3: Creare un’offerta",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Ora si comincia! Redigi un’offerta per la tua prima auto. Rifletti sulle coperture assolutamente indispensabili e su quelle che vorresti stipulare in aggiunta.
                                        Per farlo, utilizza l’apposito strumento messo a disposizione dalla tua azienda. In alternativa puoi anche avvalerti di uno strumento online.</p>
                                        <p>
                                        Potresti dover «ritoccare» un po’ il tuo anno di nascita per poter redigere un’offerta destinata a te.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho fatto un'offerta.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 4: Note e domande",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Durante il processo prendi appunti rispondendo alle seguenti domande:"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quali passaggi hai seguito per redigere l’offerta?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quali difficoltà hai incontrato nel redigere l’offerta? Come le hai risolte?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quali dati sono assolutamente necessari per poter redigere un’offerta accurata riguardante un veicolo a motore?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quali ulteriori coperture hai scelto? Quali sono state le tue considerazioni in merito?"
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quali sono i fattori/gli elementi che determinano in misura maggiore l’ammontare del premio?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 5: Formazione di presenza",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "<p>Porta l’offerta e gli appunti al training in presenza.</p>"
                                    "<p>Non dimenticare le relative CGA. Va bene anche se porti con te i documenti solo in formato elettronico.</p>"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_kickoff_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Circle Kickoff",
        effort_required="ca. 2 Stunden",
        intro_text=replace_whitespace(
            """
            <h3>Handlungskompetenzen, Arbeitssituationen & Leistungsziele</h3>
            <p>
            Handlungskompetenz d2: Informations- und Beratungsgespräch mit Kunden oder Lieferanten führen<br/>
            Arbeitssituation 4: Kunden beraten und dazugehörige Prozesse abwickeln<br/>
            <ul>
            <li>d2.pv.ük1: Sie beschreiben die wichtigsten gesetzlichen Grundlagen im Versicherungsbereich umfassend</li>
            </ul>
            </p>

            <p>
            Handlungskompetenz c3: Betriebliche Prozesse dokumentieren, koordinieren und umsetzen<br/>
            Arbeitssituation 5: Anträge verarbeiten, Verträge gestalten, Produkte entwickeln und pflegen<br/>
            <ul>
            <li>c3.pv.ük6: Sie nennen die gängigen Grundsätze bei der Gestaltung von Produkten und Dienstleistungen im Versicherungsbereich (K1)</li>
            </ul>
            </p>

            <h3>Ausgangslage</h3>
            <p>
            Das Leben hat nicht nur Sonnenseiten, es birgt auch Risiken in sich. So können wir schon morgen einen
            Unfall haben oder schwer erkranken. Oder ein Haus wird durch ein Hagelzug ziemlich beschädigt. Vor
            solchen Risiken kann sich niemand vollständig schützen. Jedoch können wir uns gegen den finanziellen
            Schaden absichern. Diese Art von Schutz bieten Versicherungen.<br/>
            In dieser Sequenz beschäftigen wir uns damit, das eigentlich eine Versicherung ausmacht.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Verschaffe dir einen ersten Überblick zum Thema.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Schaue dazu das folgende Video: <a href="https://www.youtube.com/watch?v=NgttivRt6Fo&list=PL1caXvEGRT26oPfYc2C7CbYrldQQglzFI&index=2" target="_blank"> Wie funktioniert eine Versicherung? – Einfach erklärt </a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ja, ich habe das Video angeschaut und verstanden."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: «Idee Versicherung» lesen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Lese und bearbeite im Buch «Idee Versicherung» die Seiten 12 bis 30."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ja, ich habe die Seiten gelesen und verstanden."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Skizze erstellen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Erstelle aufgrund des Gelesenen eine Skizze, welche für dich das Grundprinzip einer Versicherung darstellt.
                                        </p>
                                        <p>
                                        Nimm diese Skizze mit in den Unterricht.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe die Skizze erstellt.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_fr_kickoff_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Circle Lancement",
        effort_required="2 heures environ",
        intro_text=replace_whitespace(
            """
            <h3>Compétences opérationnelles, situations de travail & objectifs évaluateurs</h3>
            <p>
            Compétence opérationnelle d2: Mener un entretien d'information et de conseil avec des clients ou des fournisseurs <br/>
            <ul>
            <li>d2.pv.ci1: Ils décrivent de manière complète les principales bases légales dans le domaine des assurances.</li>
            </ul>
            </p>

            <p>
            Compétence opérationnelle c3: Documenter, coordonner et mettre en œuvre des processus d'entreprise <br/>
            Situation de travail 5 : traiter les demandes, rédiger les contrats, développer et entretenir les produits<br/>
            <ul>
            <li>c3.pv.ci6 : Ils citent les principes courants de la conception de produits et de services dans le domaine des assurances (C1).</li>
            </ul>
            </p>

            <h3>Situation de départ</h3>
            <p>
            La vie n'a pas que des côtés positifs, elle comporte aussi des risques. Ainsi, nous pouvons avoir un accident ou tomber gravement malade dès demain. Ou une maison peut être sérieusement endommagée par un orage de grêle. Personne ne peut se protéger complètement contre de tels risques. Nous pouvons toutefois nous protéger contre les dommages financiers. Les assurances offrent ce type de protection.<br/>
            Dans cette séquence, nous nous intéressons à ce qui constitue réellement une assurance.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 1: Obtiens un premier aperçu du sujet.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Pour cela, regarde la vidéo suivante: <a href="https://www.youtube.com/watch?v=stIqKmpTVnk" target="_blank">Comment fonctionne une assurance? Un sujet expliqué simplement</a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Oui, j'ai regardé la vidéo et j'ai compris."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 2",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Lis et traite les pages 12 à 30 du livre «Idée assurance»."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai lu et compris les pages.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 3: Créer un croquis",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Sur la base de ce que tu as lu, fais une esquisse qui représente pour toi le principe de base d'une assurance.
                                        </p>
                                        <p>
                                        Emporte ce croquis en classe.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai créé le croquis.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_it_kickoff_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Circle Introduzione - Incarico di preparazione",
        effort_required="circa 2 ore",
        intro_text=replace_whitespace(
            """
            <h3>Competenze operativa, situazioni di lavoro e obiettivi di valutazione</h3>
            <p>
            Competenza operativa d2: condurre colloqui informativi e di consulenza con clienti o fornitori.</br>
            Situazione lavorativa 4: consigliare i clienti e svolgere i relativi processi<br/>
            <ul>
            <li>d2.pv.ci1: Illustrano in modo completo le principali basi legali per il settore assicurativo. (C2)</li>
            </ul>
            </p>

            <p>
            Competenza operativa c3: documentare, coordinare e attuare processi aziendali<br/>
            Situazione lavorativa 5: trattare proposte, allestire contratti, sviluppare e gestire prodotti.<br/>
            <ul>
            <li>c3.pv.ci6: Indicano i principi essenziali nell'allestimento di prodotti e servizi in ambito assicurativo. (C1).</li>
            </ul>
            </p>

            <h3>Situazione iniziale</h3>
            <p>
            La vita non ha solo lati positivi, ma comporta anche dei rischi. Domani possiamo avere un incidente o ammalarci gravemente. Oppure una casa può essere gravemente danneggiata da una grandinata. Nessuno può proteggersi completamente da questi rischi. Tuttavia, possiamo proteggerci dai danni economici. Questo tipo di protezione è offerto dalle compagnie di assicurazione.
            In questa sequenza esaminiamo ciò che costituisce effettivamente un'assicurazione.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 1: Ottenete una prima panoramica dell'argomento.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    'Guardate il seguente video: <a href="https://www.youtube.com/watch?v=-qcrvs2AWcM" target="_blank">Come funziona un’assicurazione? – I punti chiave</a>'
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho visto il video e ho capito.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 2",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Leggete e lavorate le pagine da 12 a 29 del libro «AssicurIdea»."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho letto e compreso le pagine.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 3: Crea uno schizzo",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Sulla base di quanto letto, disegnate uno schizzo che rappresenti il principio base dell'assicurazione per voi.
                                        </p>
                                        <p>
                                        Portate questo disegno in classe.
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho creato lo schizzo.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_basis_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Circle Basis",
        effort_required="ca. 1 Tag",
        intro_text=replace_whitespace(
            """
            <h3>Handlungskompetenzen, Arbeitssituationen & Leistungsziele</h3>
            <p>
            Handlungskompetenz d2: Informations- und Beratungsgespräch mit Kunden oder Lieferanten führen<br/>
            Arbeitssituation 4: Kunden beraten und dazugehörige Prozesse abwickeln<br/>
            <ul>
            <li>d2.pv.ük1: Sie beschreiben die wichtigsten gesetzlichen Grundlagen im Versicherungsbereich umfassend (K2).</li>
            </ul>
            </p>

            <p>
            Handlungskompetenz c3: Betriebliche Prozesse dokumentieren, koordinieren und umsetzen<br/>
            Arbeitssituation 5: Anträge verarbeiten, Verträge gestalten, Produkte entwickeln und pflegen<br/>
            <ul>
            <li>c3.pv.ük6: Sie nennen die gängigen Grundsätze bei der Gestaltung von Produkten und Dienstleistungen im Versicherungsbereich (K1)</li>
            </ul>
            </p>

            <h3>Ausgangslage</h3>
            <p>
            Du bist in einer spannenden Branche gelandet. In der Welt der Versicherungen. Für das Funktionieren
            einer modernen Volkswirtschaft sind Versicherungen von grosser Bedeutung. Deshalb ist es zwingend
            notwendig, dass du dich mit den Grundlagen der Versicherungen auseinandersetzt.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Verschaffe dir einen ersten Überblick zum Thema.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    Verschaffe dir einen ersten Überblick zu den unterschiedlichen Prozessen
                                    eines Versicherungsunternehmens. Lese dazu im Lernmedium «Kunde und
                                    Versicherung» den Abschnitt «Die Wertschöpfungsprozesse eines
                                    Versicherers» (Seiten 14 bis 17)
                                    """
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe den Abschnitt gelesen.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Interview",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    <p>Interviewe in deinem Lehrbetrieb je eine Person aus zwei von dir gewählten
                                    Geschäftsprozess-Bereichen (z. B. Underwriting und Schaden) und frage sie
                                    folgendes:</p>
                                    <ul>
                                    <li>Welches sind die 2 grössten Herausforderungen in deinem Bereich?</li>
                                    <li>Was macht den Job in deinem Bereich besonders spannend?</li>
                                    </ul>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notiere deine Ergebnisse elektronisch oder physisch und bring alles ins Training mit."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Überblick Kennzahlen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Verschaffe dir einen ersten Überblick zu den unterschiedlichen Kennzahlen.
                                        Lese dazu im Lernmedium «Kunde und Versicherung» den Abschnitt «Das
                                        Unternehmen Versicherung in Zahlen» (Seiten 26 bis 32)
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe den Abschnitt gelesen.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Kennzahlen im Detail",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Bring aus deinem Lehrbetrieb 3 Kennzahlen aus dem letzten Geschäftsjahr in Erfahrung:
                                        </p>
                                        <ul>
                                        <li>Prämieneinnahmen in Franken</li>
                                        <li>Kostenaufwand in Franken</li>
                                        <li>Schadenaufwand / Schadenzahlungen in Franken</li>
                                        </ul>
                                        <p>Wenn du nicht weiterkommst, frag deine Ansprechperson im Lehrbetrieb.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notiere deine Ergebnisse elektronisch oder physisch und bring alles ins Training mit."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 5: Rechte und Pflichten",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Lese im Lehrmittel «Kunde und Versicherung» den Abschnitt «Die Rechteund Pflichten der Parteien» (Seiten 130 bis 141)</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe den Abschnitt gelesen.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 6: Versicherungsvertraggesetz (VVG)",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Besorge dir ein VVG (Versicherungsvertragsgesetz) auf <a href="https://www.fedlex.admin.ch/eli/cc/24/719_735_717/de">www.fedlex.admin.ch</a></p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich habe das VVG besorgt.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 7: Rechte und Pflichten im Lehrbetrieb",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Kläre im Lehrbetrieb zwei Fragen:
                                        </p>
                                        <ul>
                                        <li>Wie geht dein Lehrbetrieb vor, wenn der Kunde die Prämie nicht zahlt?</li>
                                        <li>Kostenaufwand in Franken</li>
                                        <li>Wie geht dein Lehrbetrieb vor, wenn der Kunde ein Schadenereignis grobfahrlässig herbeigeführt hat?</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notiere deine Ergebnisse elektronisch oder physisch und bring alles ins Training mit."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_fr_basis_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Circle Base",
        effort_required="1 jour environ",
        intro_text=replace_whitespace(
            """
            <h3>Compétences opérationnelles, situations de travail & objectifs évaluateurs</h3>
            <p>
            Compétence opérationnelle d2: Mener des entretiens d’information et de conseil avec des clients et des fournisseurs<br/>
            Situation de travail 4: Conseiller les clients et s’occuper des processus correspondants<br/>
            <ul>
            <li>d2.pv.ci1 : Ils décrivent dans le détail les principales bases légales dans le domaine de l’assurance. (C2)</li>
            </ul>
            </p>
            <p>
            Compétence opérationnelle c3 : Documenter, coordonner et mettre en œuvre des processus de travail en entreprise<br/>
            Situation de travail 5 : Traiter les propositions, établir les contrats, développer les produits et veiller à leur évolution<br/>
            <ul>
            <li>c3.pv.ci6: Ils citent les principes les plus courants en matière de conception des produits et des services dans le domaine de l’assurance. (C1)</li>
            </ul>
            </p>

            <h3>Situation de départ</h3>
            <p>
            Tu as atterri dans un secteur passionnant. Dans le monde des assurances. Les assurances sont d'une grande importance pour le fonctionnement d'une économie moderne. C'est pourquoi il est impératif que tu te familiarises avec les bases des assurances.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 1: Obtenir un premier aperçu du sujet.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    Obtiens un premier aperçu des différents processus d'une entreprise d'assurance. Lis à cet effet dans le support didactique «ClientsAssurance"»  le paragraphe «Les processus de création de valeur d’un assureur» (pages 14 à 17)
                                    """
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai lu la section.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 2: Entretien",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    <p>Interroge dans ton entreprise d'apprentissage une personne de chacun des deux domaines de processus commerciaux que tu as choisis (par ex. souscription et sinistres) et pose-lui les questions suivantes:</p>
                                    <ul>
                                    <li>Quels sont les deux plus grands défis dans ton domaine?</li>
                                    <li>Qu'est-ce qui rend le travail dans ton domaine particulièrement passionnant?</li>
                                    </ul>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notez vos résultats électroniquement ou physiquement et apportez tout à l'entraînement."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 3: Aperçu des chiffres clés",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Procure-toi un premier aperçu des différents chiffres clés. Lis à cet effet dans le support didactique «ClientsAssurance"» la section «L’entreprise d’assurance en chiffres» (pages 25 à 31)
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai lu la section.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 4: Les chiffres clés en détail",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Demande à ton entreprise d'apprentissage de te fournir 3 chiffres clés de l'exercice comptable précédent:
                                        </p>
                                        <ul>
                                        <li>Primes encaissées en francs</li>
                                        <li>Coûts/frais en francs</li>
                                        <li>Charges de sinistres / paiements de sinistres en francs</li>
                                        </ul>
                                        <p>Si tu n'y arrives pas, demande à ton interlocuteur dans l'entreprise formatrice.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notez vos résultats électroniquement ou physiquement et apportez tout à l'entraînement."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 5: Droits et obligations",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Lis dans le manuel «Client et assurance» la section «Les droits et obligations des parties contractantes» (ages 130 à 141)</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Oui, j'ai lu la section.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 6: LCA (loi sur le contrat d'assurance)",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Procure-toi une LCA (loi sur le contrat d'assurance) sur <a href="https://www.fedlex.admin.ch/eli/cc/24/719_735_717/fr">www.fedlex.admin.ch</a></p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(text=RichText("Oui, j'ai le LCA.")),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Tâche partielle 7: Droits et obligations dans l'entreprise formatrice",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Clarifie deux questions dans l'entreprise formatrice:
                                        </p>
                                        <ul>
                                        <li>Comment ton entreprise formatrice procède-t-elle lorsque le client ne paie pas la prime?</li>
                                        <li>Comment ton entreprise formatrice procède-t-elle lorsque le client a provoqué un sinistre par négligence grave?</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Notez vos résultats électroniquement ou physiquement et apportez tout à l'entraînement."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_it_basis_prep_assignment(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.PREP_ASSIGNMENT.name,
        title="Cercle Base",
        effort_required="Circa 1 giornon",
        intro_text=replace_whitespace(
            """
            <h3>Competenze operative, situazioni di lavoro e obiettivi di valutazione</h3>
            <p>
            Competenza operativa d2: Conduzione di colloqui informativi e di consulenza con clienti o fornitori<br/>
            Situazione lavorativa 4: consigliare i clienti e svolgere i relativi processi<br/>
            <ul>
            <li>d2.pv.ci1: Illustrano in modo completo le principali basi legali per il settore assicurativo (C2).</li>
            </ul>
            </p>
            <p>
            Competenza operativa c3: documentare, coordinare e attuare i processi aziendali<br/>
            Situazione lavorativa 5: Elaborazione di applicazioni, progettazione di contratti, sviluppo e manutenzione di prodotti.<br/>
            <ul>
            <li>c3.pv.ci6: Indicano i principi essenziali nell'allestimento di prodotti e servizi in ambito assicurativo (C1).</li>
            </ul>
            </p>

            <h3>Situazione iniziale</h3>
            <p>
            Siete approdati in un settore entusiasmante. Nel mondo delle assicurazioni. Le assicurazioni sono di grande importanza per il funzionamento di un'economia moderna. Per questo motivo è indispensabile che conosciate le basi dell'assicurazione.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito  1: Ottieni una prima panoramica dell'argomento.",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    Ottenete una prima panoramica dei diversi processi di una compagnia assicurativa. Leggete la sezione «I processi a valore aggiunto di un assicuratore"» (pagine da 14 a 18) nel supporto didattico «Cliente e assicurazione».
                                    """
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho letto la sezione.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 2: Colloquio",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    """
                                    <p>Intervistate una persona per ciascuna delle due campi di processo aziendale prescelte (ad esempio, sottoscrizione e sinistri) nella vostra azienda e chiedete loro quanto segue:</p>
                                    <ul>
                                    <li>Quali sono le due sfide più grandi nel tuo campo d’attività?</li>
                                    <li>Cosa rende particolarmente stimolante il lavoro nel tuo campo d’attività?</li>
                                    </ul>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Registrate i vostri risultati elettronicamente o fisicamente e portate tutto alla formazione."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 3: Panoramica delle cifre chiave",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Ottenete una prima panoramica delle diverse cifre indicative. Leggete la sezione «L’impresa ‘assicurazione’ in cifre» (pagine 26-32) nel mezzo di apprendimento «Cliente e assicurazione»
                                        </p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho letto la sezione.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 4: Dati chiave in dettaglio",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Scoprite 3 cifre indicative della vostra azienda formatrice nell'ultimo anno d’esercizio:
                                        </p>
                                        <ul>
                                        <li>Raccolta premi in franchi</li>
                                        <li>Costi in franchi</li>
                                        <li>Costi per sinistri / pagamenti di sinistri in franchi</li>
                                        </ul>
                                        <p>Se siete bloccati, chiedete al vostro referente in azienda.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Registrate i vostri risultati elettronicamente o fisicamente e portate tutto alla formazione."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 5: Droits et obligations",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Leggete la sezione «Diritti e obblighi delle parti» (pagine 131-143) nel mezzo di apprendimento «Cliente e assicurazione»</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Sì, ho letto la sezione.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 6: LCA (Legge sul contratto d'assicurazione)",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Cliccate sul link del LCA <a href="https://www.fedlex.admin.ch/eli/cc/24/719_735_717/fr">RS 221.229.1 - Legge federale del 2 aprile 1908 sul contratto d'assicurazione (Legge sul contratto d'assicurazione, LCA) (admin.ch)</a> oppure ottenete la LCA in formato cartaceo dall'azienda formatrice.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(text=RichText("Sì, ho ACL")),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Sottocompito 7: Diritti e doveri nell'azienda formatrice",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>
                                        Chiarire due questioni nell'azienda formatrice:
                                        </p>
                                        <ul>
                                        <li>Cosa fa la vostra azienda formatrice se il cliente non paga il premio?</li>
                                        <li>Come procede la vostra azienda formatrice se il cliente ha causato un sinistro per grave negligenza?</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Registrate i vostri risultati elettronicamente o fisicamente e portate tutto alla formazione."
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_reflection(course_id=COURSE_UK):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.REFLECTION.name,
        title="Reflexion",
        effort_required="ca. 1 Stunde",
        intro_text=replace_whitespace(
            """
            <p>
            Du hast in diesem Circle viele neue Inhalte und Inputs erhalten.
            Nun ist es Zeit, nochmals auf dein Kompetenzprofil zu schauen.
            Das Beantworten von Reflexionsfragen hilft dir den eigenen Lern- und Denkprozess sichtbar und begreifbar zu machen.
            Es deckt deine persönlichen Stärken und Schwächen während der Erarbeitung auf und hilft dir, dich laufend zu verbessern.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 1: Was gelingt mir bereits gut?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 2: Vertiefung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wo muss ich mich noch vertiefen oder nochmals repetieren? "
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 3: Was nehme ich mit?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 4: Vorbereitung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie habe ich mich auf den Circle vorbereitet (z. B. Lernzeit eingeplant)?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 5: Präsenzunterricht",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie engagiert war ich im Präsenzunterricht?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 6: Verbesserung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was will ich für den nächsten Circle im Lernprozess ändern/verbessern?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_fr_reflection(course_id=COURSE_UK_FR, circle_title="Véhicule"):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.REFLECTION.name,
        title="Reflexion",
        effort_required="",
        intro_text=replace_whitespace(
            """
            <p>
            Tu as reçu beaucoup de nouveaux contenus et d'inputs dans ce Circle. Il est maintenant temps de jeter à nouveau un coup d'œil sur ton profil de compétences. Répondre aux questions de réflexion t'aide à rendre visible et compréhensible ton propre processus d'apprentissage et de réflexion. Elle met en évidence tes forces et tes faiblesses personnelles pendant l'élaboration et t'aide à t'améliorer en permanence.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 1: Qu'est-ce que je réussis déjà bien?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 2: Approfondissment",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Où dois-je encore approfondir ou répéter? "
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 3: Qu'est-ce que je retiens?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 4: Préparation",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Comment me suis-je préparé(e) au Cercle (par ex. en prévoyant du temps d'étude)?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 5: Cours de présence",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Quel a été mon degré d'engagement dans les cours de présence?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Question 6: Amélioration",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Qu'est-ce que je veux changer/améliorer dans le processus d'apprentissage pour le prochain Circle?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_it_reflection(course_id=COURSE_UK_FR, circle_title="Véhicule"):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.REFLECTION.name,
        title="Riflessione",
        effort_required="",
        intro_text=replace_whitespace(
            """
            <p>
            In questo Circle hai ricevuto molti nuovi contenuti e input. Ora è il momento di dare un'altra occhiata al tuo profilo di competenza. Rispondere alle domande di riflessione aiuta a rendere visibile e comprensibile il proprio processo di apprendimento e di pensiero. Rivela i punti di forza e di debolezza personali durante l'elaborazione e aiuta a migliorare continuamente.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 1: Cosa sto già facendo bene?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 2: Approfondimento",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Dove devo ancora approfondire o ripetere le mie conoscenze?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 3: Cosa porterò con me?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 4: Preparazione",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Come mi sono preparato per il Circle (ad esempio, programmando il tempo di studio)?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 5: Insegnamento in classe",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText("Quanto mi sono impegnato in classe?")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Domanda 6: Miglioramento",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Cosa voglio cambiare/migliorare nel processo di apprendimento per il prossimo Circle?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_vv_reflection(
    course_id=COURSE_VERSICHERUNGSVERMITTLERIN_ID, _circle_title="Fahrzeug"
):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.REFLECTION.name,
        title="Reflexion",
        effort_required="ca. 1 Stunde",
        intro_text=replace_whitespace(
            """
            <p>
            Du hast in diesem Circle viele neue Inhalte und Inputs erhalten.
            Nun ist es Zeit, nochmals auf dein Kompetenzprofil zu schauen.
            Das Beantworten von Reflexionsfragen hilft dir den eigenen Lern- und Denkprozess sichtbar und begreifbar zu machen.
            Es deckt deine persönlichen Stärken und Schwächen während der Erarbeitung auf und hilft dir, dich laufend zu verbessern.
            </p>
        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 1: Was gelingt mir bereits gut?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 2: Vertiefung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was will ich noch vertiefen, nochmals repetieren oder mit meiner Lernbegleitung anschauen?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 3: Was nehme ich mit?",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 4: Vorbereitung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie habe ich mich auf den Circle vorbereitet (z. B. Lerninhalt aufgeteilt und Lernzeit eingeplant)?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 5: Austausch",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Wie engagiert war ich beim Austausch mit meinem Lernpartner/meiner Lernpartnerin und dem Transfer in die Praxis?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Frage 6: Verbesserung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    "Was führte zum Erfolg bzw. Misserfolg? Was will ich für den nächsten Circle im Lernprozess beibehalten oder ändern/verbessern?"
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_vv_gewinnen_casework(course_id=COURSE_VERSICHERUNGSVERMITTLERIN_ID):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Mein Kundenstamm",
        effort_required="60 bis 90 Minuten",
        needs_expert_evaluation=True,
        assignment_type=AssignmentType.PRAXIS_ASSIGNMENT.name,
        intro_text=replace_whitespace(
            """
        <h3>Thema</h3>
        <p>Zum Ausbau und zur Pflege deines Kundenportfolios gilt es nicht nur neue Kunden zu gewinnen, sondern vor allem daran zu denken, dass bei deinen bestehenden Kunden viel Potenzial liegt. Je besser du dein Portfolio kennst, desto einfacher ist es, weitere Leads zu generieren. Wenn du deinen Kundenstamm genau unter die Lupe nimmst, findest du bestimmt einige Möglichkeitenfür weitere Kundenkontakte und die Chance für weitere Abschlüsse.</p>
        <h3>Ausgangslage</h3>
        <p>
        Du hast bereits einige bestehende Kunden, die du beraten hast, oder du hast den Kundenstamm von einer Kollegin/einem Kollegen übernommen. Jetzt geht es darum, deinen Kundenstamm etwas genauer unter die Lupe zu nehmen.
        </p>
        <h3>Lernbegleitung</h3>
        <p>Finde innerhalb deiner Organisation eine Person, die dich, während dem Lernprozess begleitet und dir Feedback zu den Ergebnissen deines Praxisauftrags geben kann. Dies können deine Vorgesetzte/dein Vorgesetzter oder eine Kollegin/ein Kollege sein.</p>
        <p>
        Vereinbare mit dieser Person einen Termin fürs Feedback.
        </p>

        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Optimierungspotential bei bestehenden Kunden feststellen (B 3.2)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Aufgrund der Portfolios passende Zusatzprodukte anbieten (Cross-Selling) (C 1.3)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Den Kontakt zu bestehenden Kunden über diverse Medien und an Kundenanlässen aufrechterhalten (C 4.1)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Die Kunden regelmässig über aktuelle Angebote und Produkte informieren (C 4.2)"
                ),
            ),
        ],
        evaluation_document_url="",
        evaluation_description="",
    )

    assignment.evaluation_tasks = []
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 1",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 2",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 3",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 4",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 5",
                max_points=0,
            ),
        ),
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Filtere nach Kundeneigenschaften",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Wer sind deine Kundinnen und Kunden? Welche Versicherungslösungen haben sie bereits abgeschlossen?</p>
                                        <p>Um die Kundendaten auszuwerten, kannst du deine Kundschaft unterschiedlich gruppieren.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Nach welchen Kundeneigenschaften kannst du filtern?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wozu dient diese Selektierung?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Filtere deinen Kundenstamm z. B. nach «Altersgruppe: 50+»</p>
                                    <p>Wähle aus dem Filterergebnis einen Kunden/eine Kundin aus und schau dir dessen/deren Policen an: Welche Versicherungen hat er/sie bereits?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Bei welchen Bereichensiehst du bei dieser Kundin/diesem Kunden noch Potenzial für weitere Versicherungen?</p>
                                    <p>Ziehe das Versicherungsangebot deiner Gesellschaft bei.</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Formuliere für dich ein paar mögliche Sätze, um mit diesem Kunden/dieser Kundin per Telefon einen Beratungstermin zu vereinbaren.</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Filtere nach Versicherungen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Filtere nach VersicherungenNebst den Kundeneigenschaften kannst du im Kundenstamm auch nach spezifischen Versicherungen suchen, um Unter-/Überversicherung oder Lücken zu entdecken oder um Up- oder Cross-Selling anzuwenden.
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Suche in den bestehenden Policen nach einer möglichen Unter- oder Überversicherung. Worauf achtest du?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Filtere deinen Kundenstamm z. B. nach «Motorfahrzeugversicherung: Vollkasko»</p>
                                    <p>Wähle aus dem Filterergebnis einen Kunden/eine Kundin aus: Passt die Motorfahrzeug-Police noch zur aktuellen Situation (Fahrzeugalter, Pannenhilfe)?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wo siehst du noch Potenzial für weitere Versicherungen?</p>
                                    <p>Nutze dabei das Versicherungsangebot deiner Gesellschaft.</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wie kontaktierst du diesen Kunden/diese Kundin, um ihn/sie auf eine passendere Versicherungslösung hinzuweisen?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Filtere nach besonderen Ereignissen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Bei den Beratungsgesprächen hast du oder deine Vorgänger Notizen zu besonderen Ereignissen deiner Kunden und Kundinnen festgehalten. Nütze solche Ereignisse für die Kontaktaufnahme mit deiner Kundschaft.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Ereignisse im Leben einer Kundin/eines Kunden können welches Versicherungspotenzial bieten?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Beschäftige dich mit den Möglichkeiten deines Systems. Welche Filtermöglichkeiten stehen dir zur Verfügung?</p>
                                    <p>Notiere dir, welche Filterfunktionen du besonders hilfreich findest und wie du sie aktiv nutzen willst.</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Kundentelefonate",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Notiere, welche fünf Kunden du nächste Woche für ein Beratungsgespräch telefonisch kontaktieren willst.</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 5: Kundentelefonate2",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Notiere, welche hundert Kunden du nächste Woche für ein Beratungsgespräch telefonisch kontaktieren willst.</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_vv_einkommenssicherung_casework(
    course_id=COURSE_VERSICHERUNGSVERMITTLERIN_ID,
):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Heirat: Was ändert sich",
        effort_required="45 bis 90 Minuten",
        assignment_type=AssignmentType.PRAXIS_ASSIGNMENT.name,
        intro_text=replace_whitespace(
            """
        <h3>Thema</h3>
        <p>Welche Auswirkungen hat eine Heirat bezüglich Absicherung durch die Sozialversicherungen und durch private Versicherungen? Was ändert sich bezüglich Begünstigung, Erbrecht und steuerlicher Situation?</p>
        <p>Was muss bei den Vorsorgelösungen angepasst werden?</p>
        <h3>Ausgangslage</h3>
        <p>
        In deinem Beratungsalltag begegnest du unterschiedlichen Lebens- und Familienformen. Dabei ist es wichtig zu wissen, welche Leistungen von den Sozialversicherungen zu erwarten sind. Dieser Praxisauftrag legt den Fokus auf den Vergleich, wenn ein Paar mit Kind entweder im Konkubinat lebt oder bald heiratet. Bearbeite dazu die nachfolgenden Aufgaben.
        </p>
        <p>
        Du kennst den Fall von Patrizia Feller und Marco Bonsera. Sie überlegen sich, ob eine Heirat aufgrund des gemeinsamen Kindes sinnvoll sein könnte. Zeige auf, wie sich die Situation verändert, wenn die beiden heiraten würden.
        </p>
        <h3>Lernbegleitung</h3>
        <p>Finde innerhalb deiner Organisation eine Person, die dich, während dem Lernprozess begleitet und dir Feedback zu den Ergebnissen deines Praxisauftrags geben kann. Dies können deine Vorgesetzte/dein Vorgesetzter oder eine Kollegin/ein Kollege sein.</p>
        <p>
        Vereinbare mit dieser Person einen Termin fürs Feedback.
        </p>
        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Durch eine Bestandesaufnahme der aktuellen Policen prüfen, ob die Leistungen dem Bedarf des Kunden entsprechen (C1/1)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Den Kunden bedarfsgerechte Vorschläge für Anpassungen der Versicherungslösungen unterbreiten (C1/2)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Änderungswünsche der Kundinnen/Kunden entgegennehmen und bestehende Verträge anpassen (C2)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Die Daten der Kundinnen/Kunden und deren Portfolio (Policen) auf aktuellem Stand halten (C2/4)"
                ),
            ),
        ],
        evaluation_document_url="",
        evaluation_description="",
    )

    assignment.evaluation_tasks = []

    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 1",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 2",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 3",
                max_points=0,
            ),
        ),
    )
    assignment.evaluation_tasks.append(
        (
            "task",
            EvaluationTaskBlockFactory(
                title="Feedback zu Teilaufgabe 4",
                max_points=0,
            ),
        ),
    )

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Ausgangslage/Unterlagen",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Welche Unterlagen und Informationen brauchst du generell, um die Vorsorge-Situation deiner Kunden analysieren zu können?
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Da du erst kürzlich für die beiden eine Vorsorgeanalyse erstellt hast, kannst du dir hier <a href="/static/media/assignments/VV_einkommenssicherung_d_Vorsorgeanalyse_Feller_Bonsera_2023.pdf">die Analyse</a> nochmals anschauen. Die beiden sind im Konkubinat und haben vor einigen Monaten ihre erste gemeinsame Tochter (Elina) bekommen.
                                        """
                                    )
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Änderungen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Zeige auf, wie sich die Vorsorgesituation verändert, wenn die beiden heiraten würden. Welche Änderungen gibt es bei der 1. Säule?<p>
                                        <p>Wie hoch ist die jährliche maximale AHV-Altersrente für Ehepaare?</p>
                                        <p>Berechne die jährliche AHV-Witwen- und AHV-Witwerrente für die beiden.</p>
                                        <ul>
                                          <li>Durchschnittl. Einkommen Patrizia: CHF 55'000</li>
                                          <li>Durchschnittl. Einkommen Marco: CHF65'000</li>
                                        </ul>
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Welche Änderungen gibt es bei der 2. Säule im Falle eines Unfalls?<p>
                                        <p>Berechne die jährliche maximale UVG-Witwen- und UVG-Witwerrente für die beiden.</p>
                                        <ul>
                                          <li>Durchschnittl. Einkommen Patrizia: CHF 28'000</li>
                                          <li>Durchschnittl. Einkommen Marco: CHF115'200</li>
                                        </ul>
                                        <p>Welche Änderungen gibt es bei der 2. Säule im Falle einer Krankheit?</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        ("user_text_input", UserTextInputBlockFactory()),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Erb- und Steuerrecht",
                # TODO: add document upload
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Gibt es zusätzliche Deckungen, die du der Person empfehlen würdest? Begründe deine Empfehlung</p>
                                    <p>Was ist bei verheirateten Paaren steuertechnisch anders?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Generelle Änderungen",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Punkte aktualisierst du für das neu verheiratete Paar im CRM?</p>
                                    <p>Welche Versicherungen des Paars brauchen Anpassungen?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_vv_gesundheit_casework(course_id=COURSE_VERSICHERUNGSVERMITTLERIN_ID):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        title="Krankenversicherung: Passt die Lösung noch?",
        effort_required="60 bis 90 Minuten",
        assignment_type=AssignmentType.PRAXIS_ASSIGNMENT.name,
        intro_text=replace_whitespace(
            """
        <h3>Ausgangslage</h3>
        <p>
        Die Krankenversicherung bietet deinen Kunden ein Leben lang Deckung für unterschiedliche Risiken. Bei gewissen Erkrankungen können Kosten bis zu einem sechsstelligen Betrag anfallen. Aus diesem Grund ist es wichtig, die Krankenversicherungsdeckung regelmässig auf die individuellen Bedürfnisse und die Lebenssituation des Kunden zu überprüfen und wo nötig anzupassen. Dieser Praxisauftrag behandelt dieses Thema. Er legt den Fokus zusätzlich auf das Thema Zahnversicherung. Bearbeite dazu die nachfolgenden Aufgaben.
        </p>
        <p>
        Du kennst den Fall von Patrizia Feller und Marco Bonsera. Sie überlegen sich, ob eine Heirat aufgrund des gemeinsamen Kindes sinnvoll sein könnte. Zeige auf, wie sich die Situation verändert, wenn die beiden heiraten würden.
        </p>
        <h3>Lernbegleitung</h3>
        <p>Finde innerhalb deiner Organisation eine Person, die dich, während dem Lernprozess begleitet und dir Feedback zu den Ergebnissen deines Praxisauftrags geben kann. Dies können deine Vorgesetzte/dein Vorgesetzter oder eine Kollegin/ein Kollege sein.</p>
        <p>
        Vereinbare mit dieser Person einen Termin fürs Feedback.
        </p>

        """
        ),
        performance_objectives=[
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Für das zu führende Gespräch im Handlungsfeld Gesundheit geeignete Hilfsmittel und Unterlagen zusammenstellen (A2.5)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Durch eine Bestandesaufnahme der aktuellen Policen prüfen, ob die Leistungen zum Handlungsfeld Gesundheit dem Bedarf des Kunden entsprechen (C1.1)"
                ),
            ),
            (
                "performance_objective",
                PerformanceObjectiveBlockFactory(
                    text="Den Kunden bedarfsgerechte Vorschläge für Anpassungen der Versicherungslösung zum Handlungsfeld Gesundheit unterbreiten (Up-Selling) (C1.2)"
                ),
            ),
        ],
        evaluation_document_url="",
        evaluation_description="",
    )

    assignment.evaluation_tasks = []

    assignment.tasks = []
    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 1: Grundlagen der Krankenversicherung",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Risiken sind über die private Krankenversicherung gedeckt?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wann beginntdie Versicherungspflicht nach KVG?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Unterlagenund Angaben benötigst du von deinem Kunden, damit du ihn bzgl. seiner Kranken-versicherung optimal beraten kannst?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welches sind die Vorteile einer vorgeburtlichen Versicherungsdeckung?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Informationenmüssen dem Krankenversicherer möglichst rasch nach der Geburt zugestellt werden?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 2: Franchise oder Selbstbehalt",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        Hat sich der Kunde während ein paar Jahren nicht mehr mit dem Thema Krankenversicherung befasst, geht rasch einmal vergessen, was hinter dem wichtigen Begriff «Franchise» steckt. Erst wenn er diesen wieder verstanden hat, verfügt er über eine angemessene Grundlage, um gegen Ende des Jahres zu entscheiden, ob und in welchem Rahmen er diese anpassen soll.
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wie erklärst du dem Kunden diesen Begriff?</p>
                                    <p>Mach am besten gleich noch eine Skizze mit einem Rechenbeispiel dazu. Gehe davon aus, dass dein Kunde eine Franchise von CHF 500 und Behandlungskosten von CHF 1'300hat.</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 3: Wechsel der Krankenversicherung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Jeden Herbst kommuniziert das BAG die neuen, genehmigten KVG-Prämien der Schweizer Krankenkassen.</p>
                                        <p>Schau dir dazu den Prämienrechner des BAG unter <a href="www.priminfo.ch" target="_blank">www.priminfo.ch</a> genauer an.</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Erkläre deinem Kunden, welche Angaben er unbedingt braucht, um den Prämienrechner zu benutzen. Welchen Nutzen hat er davon? Was kann er von diesem entnehmen?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Fristen muss er bei einem Wechsel der KVG-Lösungbeachten?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wie wäre es bei der Zusatzversicherung nach VVG?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 4: Zahnversicherung",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    replace_whitespace(
                                        """
                                        <p>Die Zahnversicherung – ein Thema, welches die meisten Kunden interessiert. Doch kaum einer weiss Bescheid. Wie sieht es bei dir aus?</p>
                                        """
                                    )
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Weshalb ist dieses Thema wichtig?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Kosten deckt die Grundversicherung? Welche relevanten Risiken sind nicht gedeckt?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Zahnspangen-Kosten bei Kindern: Wie können diese gedeckt werden?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welche Tipps gibst du dabei deinem Kunden?</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Welcher kritische Punkt ist bei diesem Thema zu beachten?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Teilaufgabe 5: Reflexion und Learnings",
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Wie ist dir die Vor-bereitung der einzelnen Themen für eine potenzielle Kundenberatunggelungen? Was verlief gut und was verlief weniger gut? Begründe deine Einschätzung.</p>
                                    """
                                )
                            ),
                        ),
                        (
                            "user_text_input",
                            UserTextInputBlockFactory(
                                text=RichText(
                                    """
                                    <p>Leite daraus deine Learnings ab. Was konntest du noch frei und ohne Hilfsmittel erklären? Wie könntest du einzelne Punkte verständlicher erklären?</p>
                                    """
                                )
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment


def create_uk_condition_acceptance(course_id=COURSE_UK_FR):
    assignment_list_page = (
        CoursePage.objects.get(course_id=course_id)
        .get_children()
        .exact_type(AssignmentListPage)
        .first()
    )

    assignment = AssignmentFactory(
        parent=assignment_list_page,
        assignment_type=AssignmentType.CONDITION_ACCEPTANCE.name,
        title="Redlichkeitserklärung",
        intro_text=replace_whitespace(
            """

            <h3>Was akzeptierst du?</h3>

            <p>

            Die folgende Redlichkeitserklärung ist ein wichtiges Dokument, das bestätigt, dass die Arbeit, die du einreichst, ganz und gar deine eigene ist und dass du alle Regeln der akademischen Integrität eingehalten hast. Akademische Integrität beinhaltet Ehrlichkeit, Verantwortung und Respekt für das geistige Eigentum anderer. Dies bedeutet, dass du keine unerlaubte Hilfe in Anspruch nimmst und dass du alle Quellen und Materialien, die du zur Unterstützung deiner Arbeit genutzt hast, korrekt zitierst und anerkennst.

            Durch das Unterzeichnen dieser Erklärung bestätigst du, dass du die Bedeutung der akademischen Integrität verstanden hast und die Verantwortung für die Einhaltung dieser Prinzipien übernimmst. Bitte bedenke, dass das Brechen dieser Regeln ernsthafte Konsequenzen nach sich ziehen kann, darunter eine Verringerung deiner Note, das Durchfallen des Kurses oder andere disziplinarische Maßnahmen.

            </p>

        """
        ),
        performance_objectives=[],
    )

    assignment.tasks = []

    assignment.tasks.append(
        (
            "task",
            TaskBlockFactory(
                title="Erklärung",
                # it is hard to create a StreamValue programmatically, we have to
                # create a `StreamValue` manually. Ask Daniel and/or Ramon
                content=StreamValue(
                    TaskContentStreamBlock(),
                    stream_data=[
                        (
                            "explanation",
                            ExplanationBlockFactory(
                                text=RichText(
                                    "Ich erkläre hiermit, dass ich diese Prüfung oder Aufgabe selbstständig und ohne unzulässige Hilfe Dritter ausgeführt habe. Alle verwendeten Quellen und Hilfsmittel sind korrekt und vollständig angegeben. Ich verstehe, dass ein Verstoß gegen diese Erklärung ernsthafte Konsequenzen nach sich ziehen kann, einschließlich, aber nicht beschränkt auf, Notenreduzierung, Kursversagen und disziplinarische Maßnahmen."
                                )
                            ),
                        ),
                        (
                            "user_confirmation",
                            ExplanationBlockFactory(
                                text=RichText("Ja, ich akzeptiere diese Bedingungen.")
                            ),
                        ),
                    ],
                ),
            ),
        )
    )

    assignment.save()

    return assignment