feat(fullstack): Add logical AND and OR operators to seed files, add Sensitiviäts-Check

2026-02-04 06:22:08 +01:00
parent 40957bd496
commit 1bc2e9b111
23 changed files with 3488 additions and 2001 deletions
--- a/api/legalconsenthub.yml
+++ b/api/legalconsenthub.yml
@@ -1548,10 +1548,9 @@ components:
          format: uuid
          nullable: true
        visibilityConditions:
-          type: array
-          items:
-            $ref: "#/components/schemas/FormElementVisibilityCondition"
-          description: List of visibility conditions (all must be met for element to be visible - AND logic)
+          $ref: "#/components/schemas/VisibilityConditionGroup"
+          nullable: true
+          description: Recursive visibility condition tree (AND/OR groups with leaf conditions)
        sectionSpawnTriggers:
          type: array
          items:
@@ -1612,9 +1611,8 @@ components:
          items:
            $ref: "#/components/schemas/FormOptionDto"
        visibilityConditions:
-          type: array
-          items:
-            $ref: "#/components/schemas/FormElementVisibilityCondition"
+          $ref: "#/components/schemas/VisibilityConditionGroup"
+          nullable: true
        sectionSpawnTriggers:
          type: array
          items:
@@ -1643,6 +1641,8 @@ components:
          $ref: "#/components/schemas/EmployeeDataCategory"
        columnConfig:
          $ref: "#/components/schemas/TableColumnConfigDto"
+        visibilityConditions:
+          $ref: "#/components/schemas/VisibilityConditionGroup"

    TableColumnConfigDto:
      type: object
@@ -1716,24 +1716,56 @@ components:
        - TABLE
        - FILE_UPLOAD

-    FormElementVisibilityCondition:
+    VisibilityConditionNode:
      type: object
-      required:
-        - formElementConditionType
-        - sourceFormElementReference
+      description: A visibility condition node - either a leaf (single condition) or a group (AND/OR of conditions). Use nodeType to determine which properties are relevant.
      properties:
+        nodeType:
+          type: string
+          enum: [LEAF, GROUP]
+          default: LEAF
+          description: Type discriminator - LEAF for single condition, GROUP for AND/OR of conditions
+        # Leaf properties (used when nodeType=LEAF)
        formElementConditionType:
          $ref: "#/components/schemas/VisibilityConditionType"
        sourceFormElementReference:
          type: string
-          description: Reference key of the source form element to check
+          nullable: true
+          description: "[LEAF] Reference key of the source form element to check"
        formElementExpectedValue:
          type: string
          nullable: true
-          description: Expected value to compare against the source element's value property. Not required for IS_EMPTY and IS_NOT_EMPTY operators.
+          description: "[LEAF] Expected value to compare against the source element's value"
        formElementOperator:
          $ref: "#/components/schemas/VisibilityConditionOperator"
-          default: EQUALS
+        # Group properties (used when nodeType=GROUP)
+        groupOperator:
+          type: string
+          enum: [AND, OR]
+          nullable: true
+          description: "[GROUP] Logical operator to combine conditions"
+        conditions:
+          type: array
+          nullable: true
+          items:
+            $ref: "#/components/schemas/VisibilityConditionNode"
+          description: "[GROUP] List of child conditions"
+
+    VisibilityConditionGroup:
+      type: object
+      description: Root-level visibility condition group containing child conditions
+      properties:
+        operator:
+          type: string
+          enum: [AND, OR]
+          nullable: true
+          description: Logical operator to combine conditions
+        conditions:
+          type: array
+          nullable: true
+          items:
+            $ref: "#/components/schemas/VisibilityConditionNode"
+          description: List of child conditions (can be leaves or nested groups)

    VisibilityConditionType:
      type: string
@@ -1748,6 +1780,8 @@ components:
        - NOT_EQUALS
        - IS_EMPTY
        - IS_NOT_EMPTY
+        - CONTAINS
+        - NOT_CONTAINS

    SectionSpawnTriggerDto:
      type: object
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form/ApplicationFormFormatService.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form/ApplicationFormFormatService.kt
@@ -11,7 +11,6 @@ import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormSnapshotD
 import com.betriebsratkanzlei.legalconsenthub_api.model.FormElementSectionSnapshotDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.FormElementSnapshotDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.FormElementSubSectionSnapshotDto
-import com.betriebsratkanzlei.legalconsenthub_api.model.FormElementVisibilityCondition
 import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import org.springframework.stereotype.Service
@@ -21,6 +20,8 @@ import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionGroup as VisibilityConditionGroupDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionNode as VisibilityConditionNodeDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionOperator as VisibilityConditionOperatorDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionType as VisibilityConditionTypeDto

@@ -168,12 +169,12 @@ class ApplicationFormFormatService(
        if (element.options.isEmpty()) return "Keine Daten" to false

        val objectMapper = jacksonObjectMapper()
-        val headers = element.options.map { LatexEscaper.escape(it.label ?: "") }
+        val headers = element.options.map { LatexEscaper.escape(it.label) }
        val columnData =
            element.options.map { option ->
                try {
                    val typeRef = object : TypeReference<List<String>>() {}
-                    objectMapper.readValue(option.value ?: "[]", typeRef)
+                    objectMapper.readValue(option.value, typeRef)
                } catch (e: Exception) {
                    emptyList<String>()
                }
@@ -268,26 +269,61 @@ class ApplicationFormFormatService(
        element: FormElementSnapshotDto,
        formElementsByRef: Map<String, FormElementSnapshotDto>,
    ): Boolean {
-        val conditions = element.visibilityConditions
-        if (conditions.isNullOrEmpty()) return true
+        val group = element.visibilityConditions ?: return true
+        if (group.conditions?.isEmpty() != false) return true

-        // All conditions must be met (AND logic)
-        return conditions.all { condition -> evaluateSingleCondition(condition, formElementsByRef) }
+        return evaluateGroup(group, formElementsByRef)
    }

-    private fun evaluateSingleCondition(
-        condition: FormElementVisibilityCondition,
+    private fun evaluateGroup(
+        group: VisibilityConditionGroupDto,
        formElementsByRef: Map<String, FormElementSnapshotDto>,
    ): Boolean {
-        val sourceElement = formElementsByRef[condition.sourceFormElementReference] ?: return false
+        val conditions = group.conditions ?: return true
+        val results = conditions.map { evaluateNode(it, formElementsByRef) }
+        return when (group.operator) {
+            VisibilityConditionGroupDto.Operator.AND -> results.all { it }
+            VisibilityConditionGroupDto.Operator.OR -> results.any { it }
+            null -> true
+        }
+    }
+
+    private fun evaluateNode(
+        node: VisibilityConditionNodeDto,
+        formElementsByRef: Map<String, FormElementSnapshotDto>,
+    ): Boolean =
+        when (node.nodeType) {
+            VisibilityConditionNodeDto.NodeType.LEAF, null -> evaluateLeafCondition(node, formElementsByRef)
+            VisibilityConditionNodeDto.NodeType.GROUP -> {
+                val nestedGroup =
+                    VisibilityConditionGroupDto(
+                        operator =
+                            when (node.groupOperator) {
+                                VisibilityConditionNodeDto.GroupOperator.AND -> VisibilityConditionGroupDto.Operator.AND
+                                VisibilityConditionNodeDto.GroupOperator.OR -> VisibilityConditionGroupDto.Operator.OR
+                                null -> VisibilityConditionGroupDto.Operator.AND
+                            },
+                        conditions = node.conditions,
+                    )
+                evaluateGroup(nestedGroup, formElementsByRef)
+            }
+        }
+
+    private fun evaluateLeafCondition(
+        node: VisibilityConditionNodeDto,
+        formElementsByRef: Map<String, FormElementSnapshotDto>,
+    ): Boolean {
+        val sourceRef = node.sourceFormElementReference ?: return false
+        val sourceElement = formElementsByRef[sourceRef] ?: return false
        val sourceValue = getFormElementValue(sourceElement)

-        val operator = condition.formElementOperator ?: VisibilityConditionOperatorDto.EQUALS
-        val conditionMet = evaluateCondition(sourceValue, condition.formElementExpectedValue, operator)
+        val operator = node.formElementOperator ?: VisibilityConditionOperatorDto.EQUALS
+        val conditionMet = evaluateCondition(sourceValue, node.formElementExpectedValue ?: "", operator)

-        return when (condition.formElementConditionType) {
+        return when (node.formElementConditionType) {
            VisibilityConditionTypeDto.SHOW -> conditionMet
            VisibilityConditionTypeDto.HIDE -> !conditionMet
+            null -> conditionMet
        }
    }

@@ -314,5 +350,9 @@ class ApplicationFormFormatService(
                expectedValue?.let { !actualValue.equals(it, ignoreCase = true) } ?: false
            VisibilityConditionOperatorDto.IS_EMPTY -> actualValue.isEmpty()
            VisibilityConditionOperatorDto.IS_NOT_EMPTY -> actualValue.isNotEmpty()
+            VisibilityConditionOperatorDto.CONTAINS ->
+                expectedValue?.let { actualValue.contains(it, ignoreCase = true) } ?: false
+            VisibilityConditionOperatorDto.NOT_CONTAINS ->
+                expectedValue?.let { !actualValue.contains(it, ignoreCase = true) } ?: true
        }
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form_version/ApplicationFormVersionService.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/application_form_version/ApplicationFormVersionService.kt
@@ -127,10 +127,8 @@ class ApplicationFormVersionService(
                                                type = element.type,
                                                options = element.options.map { formOptionMapper.toFormOptionDto(it) },
                                                visibilityConditions =
-                                                    element.visibilityConditions
-                                                        .map {
-                                                            visibilityConditionMapper
-                                                                .toFormElementVisibilityConditionDto(it)
+                                                    element.visibilityConditions?.let {
+                                                        visibilityConditionMapper.toGroupConditionDto(it)
                                                    },
                                                sectionSpawnTriggers =
                                                    element.sectionSpawnTriggers.map {
@@ -186,10 +184,9 @@ class ApplicationFormVersionService(
                                .map { formOptionMapper.toFormOption(it) }
                                .toMutableList(),
                        visibilityConditions =
-                            elementSnapshot.visibilityConditions
-                                ?.map { visibilityConditionMapper.toFormElementVisibilityCondition(it) }
-                                ?.toMutableList()
-                                ?: mutableListOf(),
+                            elementSnapshot.visibilityConditions?.let {
+                                visibilityConditionMapper.toGroupCondition(it)
+                            },
                        sectionSpawnTriggers =
                            elementSnapshot.sectionSpawnTriggers
                                ?.map { spawnTriggerMapper.toSectionSpawnTrigger(it) }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/JacksonConfig.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/JacksonConfig.kt
@@ -0,0 +1,11 @@
+package com.betriebsratkanzlei.legalconsenthub.config
+
+import com.fasterxml.jackson.databind.Module
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+class JacksonConfig {
+    @Bean
+    fun visibilityConditionJacksonModule(): Module = visibilityConditionModule()
+}
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/VisibilityConditionNodeDeserializer.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/config/VisibilityConditionNodeDeserializer.kt
@@ -0,0 +1,99 @@
+package com.betriebsratkanzlei.legalconsenthub.config
+
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionNode
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionOperator
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionType
+import com.fasterxml.jackson.core.JsonGenerator
+import com.fasterxml.jackson.core.JsonParser
+import com.fasterxml.jackson.databind.DeserializationContext
+import com.fasterxml.jackson.databind.JsonDeserializer
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.JsonSerializer
+import com.fasterxml.jackson.databind.SerializerProvider
+import com.fasterxml.jackson.databind.module.SimpleModule
+
+class VisibilityConditionNodeDeserializer : JsonDeserializer<VisibilityConditionNode>() {
+    override fun deserialize(
+        p: JsonParser,
+        ctxt: DeserializationContext,
+    ): VisibilityConditionNode {
+        val node = p.codec.readTree<JsonNode>(p)
+
+        val nodeType = node.get("nodeType")?.asText()
+
+        return if (nodeType == "GROUP") {
+            val groupOperator =
+                node.get("groupOperator")?.asText()?.let {
+                    VisibilityConditionNode.GroupOperator.forValue(it)
+                }
+            val conditions =
+                node.get("conditions")?.map { childNode ->
+                    val childParser = childNode.traverse(p.codec)
+                    childParser.nextToken()
+                    deserialize(childParser, ctxt)
+                } ?: emptyList()
+            VisibilityConditionNode(
+                nodeType = VisibilityConditionNode.NodeType.GROUP,
+                groupOperator = groupOperator,
+                conditions = conditions,
+            )
+        } else {
+            // Default to LEAF for backward compatibility
+            val sourceRef = node.get("sourceFormElementReference")?.asText()
+            val conditionType =
+                node.get("formElementConditionType")?.asText()?.let {
+                    VisibilityConditionType.valueOf(it)
+                }
+            val expectedValue = node.get("formElementExpectedValue")?.asText()
+            val formElementOperator =
+                node.get("formElementOperator")?.asText()?.let {
+                    VisibilityConditionOperator.valueOf(it)
+                }
+            VisibilityConditionNode(
+                nodeType = VisibilityConditionNode.NodeType.LEAF,
+                sourceFormElementReference = sourceRef,
+                formElementConditionType = conditionType,
+                formElementExpectedValue = expectedValue,
+                formElementOperator = formElementOperator,
+            )
+        }
+    }
+}
+
+class VisibilityConditionNodeSerializer : JsonSerializer<VisibilityConditionNode>() {
+    override fun serialize(
+        value: VisibilityConditionNode,
+        gen: JsonGenerator,
+        serializers: SerializerProvider,
+    ) {
+        gen.writeStartObject()
+        gen.writeStringField("nodeType", (value.nodeType ?: VisibilityConditionNode.NodeType.LEAF).value)
+
+        if (value.nodeType == VisibilityConditionNode.NodeType.GROUP) {
+            value.groupOperator?.let { gen.writeStringField("groupOperator", it.value) }
+            gen.writeArrayFieldStart("conditions")
+            value.conditions?.forEach { serialize(it, gen, serializers) }
+            gen.writeEndArray()
+        } else {
+            value.formElementConditionType?.let {
+                gen.writeStringField("formElementConditionType", it.value)
+            }
+            value.sourceFormElementReference?.let {
+                gen.writeStringField("sourceFormElementReference", it)
+            }
+            value.formElementExpectedValue?.let {
+                gen.writeStringField("formElementExpectedValue", it)
+            }
+            value.formElementOperator?.let {
+                gen.writeStringField("formElementOperator", it.value)
+            }
+        }
+        gen.writeEndObject()
+    }
+}
+
+fun visibilityConditionModule(): SimpleModule =
+    SimpleModule("VisibilityConditionModule").apply {
+        addDeserializer(VisibilityConditionNode::class.java, VisibilityConditionNodeDeserializer())
+        addSerializer(VisibilityConditionNode::class.java, VisibilityConditionNodeSerializer())
+    }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElement.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElement.kt
@@ -12,6 +12,8 @@ import jakarta.persistence.GeneratedValue
 import jakarta.persistence.Id
 import jakarta.persistence.JoinColumn
 import jakarta.persistence.ManyToOne
+import org.hibernate.annotations.JdbcTypeCode
+import org.hibernate.type.SqlTypes
 import java.util.UUID

@Entity
@@ -30,9 +32,9 @@ class FormElement(
    @ManyToOne
    @JoinColumn(name = "form_element_sub_section_id", nullable = false)
    var formElementSubSection: FormElementSubSection? = null,
-    @ElementCollection
-    @CollectionTable(name = "visibility_conditions", joinColumns = [JoinColumn(name = "form_element_id")])
-    var visibilityConditions: MutableList<FormElementVisibilityCondition> = mutableListOf(),
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb")
+    var visibilityConditions: GroupCondition? = null,
    @ElementCollection
    @CollectionTable(name = "section_spawn_triggers", joinColumns = [JoinColumn(name = "form_element_id")])
    var sectionSpawnTriggers: MutableList<SectionSpawnTrigger> = mutableListOf(),
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementMapper.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementMapper.kt
@@ -22,8 +22,8 @@ class FormElementMapper(
                formElement.formElementSubSection?.id
                    ?: throw IllegalStateException("FormElementSubSection ID must not be null!"),
            visibilityConditions =
-                formElement.visibilityConditions.map {
-                    visibilityConditionMapper.toFormElementVisibilityConditionDto(it)
+                formElement.visibilityConditions?.let {
+                    visibilityConditionMapper.toGroupConditionDto(it)
                },
            sectionSpawnTriggers =
                formElement.sectionSpawnTriggers.map {
@@ -49,10 +49,9 @@ class FormElementMapper(
            type = formElement.type,
            formElementSubSection = formElementSubSection,
            visibilityConditions =
-                formElement.visibilityConditions
-                    ?.map { visibilityConditionMapper.toFormElementVisibilityCondition(it) }
-                    ?.toMutableList()
-                    ?: mutableListOf(),
+                formElement.visibilityConditions?.let {
+                    visibilityConditionMapper.toGroupCondition(it)
+                },
            sectionSpawnTriggers =
                formElement.sectionSpawnTriggers
                    ?.map { spawnTriggerMapper.toSectionSpawnTrigger(it) }
@@ -78,10 +77,9 @@ class FormElementMapper(
            type = formElement.type,
            formElementSubSection = formElementSubSection,
            visibilityConditions =
-                formElement.visibilityConditions
-                    ?.map { visibilityConditionMapper.toFormElementVisibilityCondition(it) }
-                    ?.toMutableList()
-                    ?: mutableListOf(),
+                formElement.visibilityConditions?.let {
+                    visibilityConditionMapper.toGroupCondition(it)
+                },
            sectionSpawnTriggers =
                formElement.sectionSpawnTriggers
                    ?.map { spawnTriggerMapper.toSectionSpawnTrigger(it) }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementVisibilityCondition.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementVisibilityCondition.kt
@@ -1,15 +0,0 @@
-package com.betriebsratkanzlei.legalconsenthub.form_element
-
-import jakarta.persistence.Embeddable
-import jakarta.persistence.EnumType
-import jakarta.persistence.Enumerated
-
-@Embeddable
-data class FormElementVisibilityCondition(
-    @Enumerated(EnumType.STRING)
-    val formElementConditionType: VisibilityConditionType,
-    val sourceFormElementReference: String,
-    val formElementExpectedValue: String?,
-    @Enumerated(EnumType.STRING)
-    val formElementOperator: VisibilityConditionOperator = VisibilityConditionOperator.EQUALS,
-)
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementVisibilityConditionMapper.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormElementVisibilityConditionMapper.kt
@@ -1,33 +1,86 @@
 package com.betriebsratkanzlei.legalconsenthub.form_element

 import org.springframework.stereotype.Component
-import com.betriebsratkanzlei.legalconsenthub_api.model.FormElementVisibilityCondition as FormElementVisibilityConditionDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionGroup as VisibilityConditionGroupDto
+import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionNode as VisibilityConditionNodeDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionOperator as VisibilityConditionOperatorDto
 import com.betriebsratkanzlei.legalconsenthub_api.model.VisibilityConditionType as VisibilityConditionTypeDto

@Component
 class FormElementVisibilityConditionMapper {
-    fun toFormElementVisibilityConditionDto(
-        condition: FormElementVisibilityCondition,
-    ): FormElementVisibilityConditionDto =
-        FormElementVisibilityConditionDto(
-            formElementConditionType = toVisibilityConditionTypeDto(condition.formElementConditionType),
-            sourceFormElementReference = condition.sourceFormElementReference,
-            formElementExpectedValue = condition.formElementExpectedValue,
-            formElementOperator = toVisibilityConditionOperatorDto(condition.formElementOperator),
+    fun toGroupConditionDto(group: GroupCondition): VisibilityConditionGroupDto =
+        VisibilityConditionGroupDto(
+            operator = toGroupOperatorDto(group.operator),
+            conditions = group.conditions.map { toNodeDto(it) },
        )

-    fun toFormElementVisibilityCondition(
-        conditionDto: FormElementVisibilityConditionDto,
-    ): FormElementVisibilityCondition =
-        FormElementVisibilityCondition(
-            formElementConditionType = toVisibilityConditionType(conditionDto.formElementConditionType),
-            sourceFormElementReference = conditionDto.sourceFormElementReference,
-            formElementExpectedValue = conditionDto.formElementExpectedValue,
+    fun toGroupCondition(groupDto: VisibilityConditionGroupDto): GroupCondition =
+        GroupCondition(
+            operator = toGroupOperator(groupDto.operator ?: VisibilityConditionGroupDto.Operator.AND),
+            conditions = groupDto.conditions?.map { toNode(it) } ?: emptyList(),
+        )
+
+    private fun toNodeDto(node: VisibilityConditionNode): VisibilityConditionNodeDto =
+        when (node) {
+            is LeafCondition ->
+                VisibilityConditionNodeDto(
+                    nodeType = VisibilityConditionNodeDto.NodeType.LEAF,
+                    sourceFormElementReference = node.sourceFormElementReference,
+                    formElementConditionType = node.formElementConditionType?.let { toVisibilityConditionTypeDto(it) },
+                    formElementExpectedValue = node.formElementExpectedValue,
+                    formElementOperator = toVisibilityConditionOperatorDto(node.formElementOperator),
+                )
+
+            is GroupCondition ->
+                VisibilityConditionNodeDto(
+                    nodeType = VisibilityConditionNodeDto.NodeType.GROUP,
+                    groupOperator = toNodeGroupOperatorDto(node.operator),
+                    conditions = node.conditions.map { toNodeDto(it) },
+                )
+        }
+
+    private fun toNode(nodeDto: VisibilityConditionNodeDto): VisibilityConditionNode =
+        when (nodeDto.nodeType) {
+            VisibilityConditionNodeDto.NodeType.GROUP ->
+                GroupCondition(
+                    operator = toGroupOperatorFromNode(nodeDto.groupOperator),
+                    conditions = nodeDto.conditions?.map { toNode(it) } ?: emptyList(),
+                )
+            VisibilityConditionNodeDto.NodeType.LEAF, null ->
+                LeafCondition(
+                    formElementConditionType = nodeDto.formElementConditionType?.let { toVisibilityConditionType(it) },
+                    sourceFormElementReference = nodeDto.sourceFormElementReference ?: "",
+                    formElementExpectedValue = nodeDto.formElementExpectedValue,
                    formElementOperator =
-                conditionDto.formElementOperator?.let { toVisibilityConditionOperator(it) }
+                        nodeDto.formElementOperator?.let { toVisibilityConditionOperator(it) }
                            ?: VisibilityConditionOperator.EQUALS,
                )
+        }
+
+    private fun toGroupOperatorDto(op: GroupOperator): VisibilityConditionGroupDto.Operator =
+        when (op) {
+            GroupOperator.AND -> VisibilityConditionGroupDto.Operator.AND
+            GroupOperator.OR -> VisibilityConditionGroupDto.Operator.OR
+        }
+
+    private fun toGroupOperator(op: VisibilityConditionGroupDto.Operator): GroupOperator =
+        when (op) {
+            VisibilityConditionGroupDto.Operator.AND -> GroupOperator.AND
+            VisibilityConditionGroupDto.Operator.OR -> GroupOperator.OR
+        }
+
+    private fun toNodeGroupOperatorDto(op: GroupOperator): VisibilityConditionNodeDto.GroupOperator =
+        when (op) {
+            GroupOperator.AND -> VisibilityConditionNodeDto.GroupOperator.AND
+            GroupOperator.OR -> VisibilityConditionNodeDto.GroupOperator.OR
+        }
+
+    private fun toGroupOperatorFromNode(op: VisibilityConditionNodeDto.GroupOperator?): GroupOperator =
+        when (op) {
+            VisibilityConditionNodeDto.GroupOperator.AND -> GroupOperator.AND
+            VisibilityConditionNodeDto.GroupOperator.OR -> GroupOperator.OR
+            null -> GroupOperator.AND
+        }

    private fun toVisibilityConditionTypeDto(type: VisibilityConditionType): VisibilityConditionTypeDto =
        when (type) {
@@ -45,27 +98,23 @@ class FormElementVisibilityConditionMapper {
        operator: VisibilityConditionOperator,
    ): VisibilityConditionOperatorDto =
        when (operator) {
-            VisibilityConditionOperator.EQUALS ->
-                VisibilityConditionOperatorDto.EQUALS
-            VisibilityConditionOperator.NOT_EQUALS ->
-                VisibilityConditionOperatorDto.NOT_EQUALS
-            VisibilityConditionOperator.IS_EMPTY ->
-                VisibilityConditionOperatorDto.IS_EMPTY
-            VisibilityConditionOperator.IS_NOT_EMPTY ->
-                VisibilityConditionOperatorDto.IS_NOT_EMPTY
+            VisibilityConditionOperator.EQUALS -> VisibilityConditionOperatorDto.EQUALS
+            VisibilityConditionOperator.NOT_EQUALS -> VisibilityConditionOperatorDto.NOT_EQUALS
+            VisibilityConditionOperator.IS_EMPTY -> VisibilityConditionOperatorDto.IS_EMPTY
+            VisibilityConditionOperator.IS_NOT_EMPTY -> VisibilityConditionOperatorDto.IS_NOT_EMPTY
+            VisibilityConditionOperator.CONTAINS -> VisibilityConditionOperatorDto.CONTAINS
+            VisibilityConditionOperator.NOT_CONTAINS -> VisibilityConditionOperatorDto.NOT_CONTAINS
        }

    private fun toVisibilityConditionOperator(
        operatorDto: VisibilityConditionOperatorDto,
    ): VisibilityConditionOperator =
        when (operatorDto) {
-            VisibilityConditionOperatorDto.EQUALS ->
-                VisibilityConditionOperator.EQUALS
-            VisibilityConditionOperatorDto.NOT_EQUALS ->
-                VisibilityConditionOperator.NOT_EQUALS
-            VisibilityConditionOperatorDto.IS_EMPTY ->
-                VisibilityConditionOperator.IS_EMPTY
-            VisibilityConditionOperatorDto.IS_NOT_EMPTY ->
-                VisibilityConditionOperator.IS_NOT_EMPTY
+            VisibilityConditionOperatorDto.EQUALS -> VisibilityConditionOperator.EQUALS
+            VisibilityConditionOperatorDto.NOT_EQUALS -> VisibilityConditionOperator.NOT_EQUALS
+            VisibilityConditionOperatorDto.IS_EMPTY -> VisibilityConditionOperator.IS_EMPTY
+            VisibilityConditionOperatorDto.IS_NOT_EMPTY -> VisibilityConditionOperator.IS_NOT_EMPTY
+            VisibilityConditionOperatorDto.CONTAINS -> VisibilityConditionOperator.CONTAINS
+            VisibilityConditionOperatorDto.NOT_CONTAINS -> VisibilityConditionOperator.NOT_CONTAINS
        }
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormOption.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormOption.kt
@@ -7,6 +7,8 @@ import jakarta.persistence.AttributeOverrides
 import jakarta.persistence.Column
 import jakarta.persistence.Embeddable
 import jakarta.persistence.Embedded
+import org.hibernate.annotations.JdbcTypeCode
+import org.hibernate.type.SqlTypes

@Embeddable
 class FormOption(
@@ -35,4 +37,7 @@ class FormOption(
        AttributeOverride(name = "isCheckbox", column = Column(name = "col_config_is_checkbox")),
    )
    var columnConfig: TableColumnConfig? = null,
+    @JdbcTypeCode(SqlTypes.JSON)
+    @Column(columnDefinition = "jsonb", name = "visibility_conditions")
+    var visibilityConditions: GroupCondition? = null,
 )
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormOptionMapper.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/FormOptionMapper.kt
@@ -6,6 +6,7 @@ import org.springframework.stereotype.Component
@Component
 class FormOptionMapper(
    private val columnConfigMapper: TableColumnConfigMapper,
+    private val visibilityConditionMapper: FormElementVisibilityConditionMapper,
 ) {
    fun toFormOptionDto(formOption: FormOption): FormOptionDto =
        FormOptionDto(
@@ -14,6 +15,10 @@ class FormOptionMapper(
            processingPurpose = formOption.processingPurpose,
            employeeDataCategory = formOption.employeeDataCategory,
            columnConfig = formOption.columnConfig?.let { columnConfigMapper.toTableColumnConfigDto(it) },
+            visibilityConditions =
+                formOption.visibilityConditions?.let {
+                    visibilityConditionMapper.toGroupConditionDto(it)
+                },
        )

    fun toFormOption(formOptionDto: FormOptionDto): FormOption =
@@ -23,5 +28,9 @@ class FormOptionMapper(
            processingPurpose = formOptionDto.processingPurpose,
            employeeDataCategory = formOptionDto.employeeDataCategory,
            columnConfig = formOptionDto.columnConfig?.let { columnConfigMapper.toTableColumnConfig(it) },
+            visibilityConditions =
+                formOptionDto.visibilityConditions?.let {
+                    visibilityConditionMapper.toGroupCondition(it)
+                },
        )
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/SectionSpawnTriggerMapper.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/SectionSpawnTriggerMapper.kt
@@ -43,6 +43,8 @@ class SectionSpawnTriggerMapper {
            VisibilityConditionOperator.NOT_EQUALS -> VisibilityConditionOperatorDto.NOT_EQUALS
            VisibilityConditionOperator.IS_EMPTY -> VisibilityConditionOperatorDto.IS_EMPTY
            VisibilityConditionOperator.IS_NOT_EMPTY -> VisibilityConditionOperatorDto.IS_NOT_EMPTY
+            VisibilityConditionOperator.CONTAINS -> VisibilityConditionOperatorDto.CONTAINS
+            VisibilityConditionOperator.NOT_CONTAINS -> VisibilityConditionOperatorDto.NOT_CONTAINS
        }

    private fun toVisibilityConditionOperator(
@@ -53,5 +55,7 @@ class SectionSpawnTriggerMapper {
            VisibilityConditionOperatorDto.NOT_EQUALS -> VisibilityConditionOperator.NOT_EQUALS
            VisibilityConditionOperatorDto.IS_EMPTY -> VisibilityConditionOperator.IS_EMPTY
            VisibilityConditionOperatorDto.IS_NOT_EMPTY -> VisibilityConditionOperator.IS_NOT_EMPTY
+            VisibilityConditionOperatorDto.CONTAINS -> VisibilityConditionOperator.CONTAINS
+            VisibilityConditionOperatorDto.NOT_CONTAINS -> VisibilityConditionOperator.NOT_CONTAINS
        }
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/TableColumnFilterMapper.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/TableColumnFilterMapper.kt
@@ -26,6 +26,8 @@ class TableColumnFilterMapper {
            VisibilityConditionOperator.NOT_EQUALS -> VisibilityConditionOperatorDto.NOT_EQUALS
            VisibilityConditionOperator.IS_EMPTY -> VisibilityConditionOperatorDto.IS_EMPTY
            VisibilityConditionOperator.IS_NOT_EMPTY -> VisibilityConditionOperatorDto.IS_NOT_EMPTY
+            VisibilityConditionOperator.CONTAINS -> VisibilityConditionOperatorDto.CONTAINS
+            VisibilityConditionOperator.NOT_CONTAINS -> VisibilityConditionOperatorDto.NOT_CONTAINS
        }

    private fun VisibilityConditionOperatorDto.toEntity(): VisibilityConditionOperator =
@@ -34,5 +36,7 @@ class TableColumnFilterMapper {
            VisibilityConditionOperatorDto.NOT_EQUALS -> VisibilityConditionOperator.NOT_EQUALS
            VisibilityConditionOperatorDto.IS_EMPTY -> VisibilityConditionOperator.IS_EMPTY
            VisibilityConditionOperatorDto.IS_NOT_EMPTY -> VisibilityConditionOperator.IS_NOT_EMPTY
+            VisibilityConditionOperatorDto.CONTAINS -> VisibilityConditionOperator.CONTAINS
+            VisibilityConditionOperatorDto.NOT_CONTAINS -> VisibilityConditionOperator.NOT_CONTAINS
        }
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/VisibilityConditionNode.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/VisibilityConditionNode.kt
@@ -0,0 +1,31 @@
+package com.betriebsratkanzlei.legalconsenthub.form_element
+
+import com.fasterxml.jackson.annotation.JsonSubTypes
+import com.fasterxml.jackson.annotation.JsonTypeInfo
+
+@JsonTypeInfo(
+    use = JsonTypeInfo.Id.DEDUCTION,
+    defaultImpl = LeafCondition::class,
+)
+@JsonSubTypes(
+    JsonSubTypes.Type(GroupCondition::class),
+    JsonSubTypes.Type(LeafCondition::class),
+)
+sealed interface VisibilityConditionNode
+
+data class GroupCondition(
+    val operator: GroupOperator,
+    val conditions: List<VisibilityConditionNode>,
+) : VisibilityConditionNode
+
+data class LeafCondition(
+    val formElementConditionType: VisibilityConditionType? = null,
+    val sourceFormElementReference: String,
+    val formElementExpectedValue: String? = null,
+    val formElementOperator: VisibilityConditionOperator = VisibilityConditionOperator.EQUALS,
+) : VisibilityConditionNode
+
+enum class GroupOperator {
+    AND,
+    OR,
+}
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/VisibilityConditionOperator.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/form_element/VisibilityConditionOperator.kt
@@ -5,4 +5,6 @@ enum class VisibilityConditionOperator {
    NOT_EQUALS,
    IS_EMPTY,
    IS_NOT_EMPTY,
+    CONTAINS,
+    NOT_CONTAINS,
 }
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/seed/InitialApplicationFormSeeder.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/seed/InitialApplicationFormSeeder.kt
@@ -3,6 +3,7 @@ package com.betriebsratkanzlei.legalconsenthub.seed
 import com.betriebsratkanzlei.legalconsenthub.application_form.ApplicationFormMapper
 import com.betriebsratkanzlei.legalconsenthub.application_form.ApplicationFormRepository
 import com.betriebsratkanzlei.legalconsenthub.application_form_version.ApplicationFormVersionService
+import com.betriebsratkanzlei.legalconsenthub.config.visibilityConditionModule
 import com.betriebsratkanzlei.legalconsenthub.user.User
 import com.betriebsratkanzlei.legalconsenthub.user.UserRepository
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormDto
@@ -25,7 +26,10 @@ class InitialApplicationFormSeeder(
    private val userRepository: UserRepository,
    private val versionService: ApplicationFormVersionService,
 ) : ApplicationRunner {
-    private val yamlMapper = ObjectMapper(YAMLFactory()).findAndRegisterModules()
+    private val yamlMapper =
+        ObjectMapper(
+            YAMLFactory(),
+        ).findAndRegisterModules().registerModule(visibilityConditionModule())

    override fun run(args: ApplicationArguments) {
        seedInitialFormIfMissing()
--- a/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/seed/InitialApplicationFormTemplateSeeder.kt
+++ b/legalconsenthub-backend/src/main/kotlin/com/betriebsratkanzlei/legalconsenthub/seed/InitialApplicationFormTemplateSeeder.kt
@@ -2,6 +2,7 @@ package com.betriebsratkanzlei.legalconsenthub.seed

 import com.betriebsratkanzlei.legalconsenthub.application_form.ApplicationFormMapper
 import com.betriebsratkanzlei.legalconsenthub.application_form.ApplicationFormRepository
+import com.betriebsratkanzlei.legalconsenthub.config.visibilityConditionModule
 import com.betriebsratkanzlei.legalconsenthub.user.User
 import com.betriebsratkanzlei.legalconsenthub.user.UserRepository
 import com.betriebsratkanzlei.legalconsenthub_api.model.ApplicationFormDto
@@ -22,7 +23,10 @@ class InitialApplicationFormTemplateSeeder(
    private val applicationFormMapper: ApplicationFormMapper,
    private val userRepository: UserRepository,
 ) : ApplicationRunner {
-    private val yamlMapper = ObjectMapper(YAMLFactory()).findAndRegisterModules()
+    private val yamlMapper =
+        ObjectMapper(
+            YAMLFactory(),
+        ).findAndRegisterModules().registerModule(visibilityConditionModule())

    override fun run(args: ApplicationArguments) {
        seedInitialTemplateIfMissing()
--- a/legalconsenthub-backend/src/main/resources/application-testcontainers.yaml
+++ b/legalconsenthub-backend/src/main/resources/application-testcontainers.yaml
@@ -13,7 +13,7 @@ spring:
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: create
-    show-sql: true
+    show-sql: false
    properties:
      hibernate:
        format_sql: true
--- a/legalconsenthub-backend/src/main/resources/db/migrations/001-schema.sql
+++ b/legalconsenthub-backend/src/main/resources/db/migrations/001-schema.sql
@@ -68,12 +68,13 @@ create table form_element_options
    form_element_id                             uuid         not null,
    col_config_filter_expected_val              varchar(255),
    col_config_filter_operator                  varchar(255) check (col_config_filter_operator in
-                                                                    ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY',
-                                                                     'IS_NOT_EMPTY')),
+                                                                    ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY',
+                                                                     'CONTAINS', 'NOT_CONTAINS')),
    col_config_source_table_ref                 varchar(255),
    label                                       varchar(255) not null,
    option_value                                TEXT         not null,
-    row_constraint_table_reference              varchar(255)
+    row_constraint_table_reference              varchar(255),
+    visibility_conditions                       jsonb
 );

 create table form_element
@@ -89,9 +90,11 @@ create table form_element
    reference                      varchar(255),
    row_preset_filter_expected_val varchar(255),
    row_preset_filter_operator     varchar(255) check (row_preset_filter_operator in
-                                                       ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY')),
+                                                       ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY', 'CONTAINS',
+                                                        'NOT_CONTAINS')),
    row_preset_source_table_ref    varchar(255),
    title                          varchar(255),
+    visibility_conditions          jsonb,
    primary key (id)
 );

@@ -141,7 +144,8 @@ create table section_spawn_triggers
    section_spawn_condition_type varchar(255) check (section_spawn_condition_type in ('SHOW', 'HIDE')),
    section_spawn_expected_value varchar(255),
    section_spawn_operator       varchar(255) check (section_spawn_operator in
-                                                     ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY')),
+                                                     ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY', 'CONTAINS',
+                                                      'NOT_CONTAINS')),
    template_reference           varchar(255)
 );

@@ -169,16 +173,6 @@ create table uploaded_file
    primary key (id)
 );

-create table visibility_conditions
-(
-    form_element_id               uuid not null,
-    form_element_condition_type   varchar(255) check (form_element_condition_type in ('SHOW', 'HIDE')),
-    form_element_expected_value   varchar(255),
-    form_element_operator         varchar(255) check (form_element_operator in
-                                                      ('EQUALS', 'NOT_EQUALS', 'IS_EMPTY', 'IS_NOT_EMPTY')),
-    source_form_element_reference varchar(255)
-);
-
 alter table if exists application_form
    add constraint FKhtad5onoy2jknhtyfmx6cvvey
    foreign key (created_by_id)
@@ -259,8 +253,3 @@ alter table if exists uploaded_file
    add constraint FKtg323a9339lx0do79gu4eftao
    foreign key (uploaded_by_id)
    references app_user;
-
-alter table if exists visibility_conditions
-    add constraint FK5xuf7bd179ogpq5a1m3g8q7jb
-    foreign key (form_element_id)
-    references form_element;
--- a/legalconsenthub-backend/src/main/resources/seed/initial_application_form.yaml
+++ b/legalconsenthub-backend/src/main/resources/seed/initial_application_form.yaml
--- a/legalconsenthub-backend/src/main/resources/seed/initial_application_form_template.yaml
+++ b/legalconsenthub-backend/src/main/resources/seed/initial_application_form_template.yaml
--- a/legalconsenthub/app/components/formelements/TheTable.vue
+++ b/legalconsenthub/app/components/formelements/TheTable.vue
@@ -78,6 +78,7 @@
 import type { FormElementDto, FormOptionDto, TableRowPresetDto } from '~~/.api-client'
 import type { TableColumn } from '@nuxt/ui'
 import { useTableCrossReferences } from '~/composables/useTableCrossReferences'
+import { useFormElementVisibility } from '~/composables/useFormElementVisibility'

 const props = defineProps<{
  formOptions: FormOptionDto[]
@@ -86,6 +87,8 @@ const props = defineProps<{
  tableRowPreset?: TableRowPresetDto
 }>()

+const { isFormOptionVisible } = useFormElementVisibility()
+
 const emit = defineEmits<{
  (e: 'update:formOptions', value: FormOptionDto[]): void
 }>()
@@ -131,16 +134,33 @@ interface DataColumn {
  colIndex: number
 }

+// Filter columns based on visibility conditions
+interface VisibleColumn {
+  option: FormOptionDto
+  originalIndex: number
+}
+
+const visibleColumns = computed<VisibleColumn[]>(() => {
+  return props.formOptions
+    .map((option, index) => ({ option, originalIndex: index }))
+    .filter(({ option }) => {
+      if (!option.visibilityConditions || !props.allFormElements) {
+        return true
+      }
+      return isFormOptionVisible(option.visibilityConditions, props.allFormElements)
+    })
+})
+
 const dataColumns = computed<DataColumn[]>(() =>
-  props.formOptions.map((_, index) => ({
-    key: `col_${index}`,
-    colIndex: index
+  visibleColumns.value.map(({ originalIndex }) => ({
+    key: `col_${originalIndex}`,
+    colIndex: originalIndex
  }))
 )

 const tableColumns = computed<TableColumn<TableRowData>[]>(() => {
-  const columns: TableColumn<TableRowData>[] = props.formOptions.map((option, index) => ({
-    accessorKey: `col_${index}`,
+  const columns: TableColumn<TableRowData>[] = visibleColumns.value.map(({ option, originalIndex }) => ({
+    accessorKey: `col_${originalIndex}`,
    header: option.label || ''
  }))

--- a/legalconsenthub/app/composables/useFormElementVisibility.ts
+++ b/legalconsenthub/app/composables/useFormElementVisibility.ts
@@ -1,15 +1,14 @@
-import type { FormElementDto, FormElementVisibilityCondition, VisibilityConditionOperator } from '~~/.api-client'
+import type { FormElementDto, VisibilityConditionGroup, VisibilityConditionNode } from '~~/.api-client'
 import {
-  VisibilityConditionOperator as VCOperator,
  VisibilityConditionType as VCType,
+  VisibilityConditionNodeNodeTypeEnum as VCNodeTypeEnum,
+  VisibilityConditionGroupOperatorEnum as VCGroupOperatorEnum,
+  VisibilityConditionNodeGroupOperatorEnum as VCNodeGroupOperatorEnum,
+  VisibilityConditionOperator as VCOperator,
  FormElementType
 } from '~~/.api-client'

 export function useFormElementVisibility() {
-  /**
-   * Evaluates visibility for all form elements based on their visibility conditions.
-   * Returns a map of element key (id or reference) to visibility status.
-   */
  function evaluateFormElementVisibility(allFormElements: FormElementDto[]): Map<string, boolean> {
    const formElementsByRef = buildFormElementsMap(allFormElements)
    const visibilityMap = new Map<string, boolean>()
@@ -25,6 +24,22 @@ export function useFormElementVisibility() {
    return visibilityMap
  }

+  /**
+   * Evaluates visibility conditions for a FormOption (e.g., table column).
+   * Unlike evaluateFormElementVisibility which works on FormElements,
+   * this evaluates standalone condition groups for options/columns.
+   */
+  function isFormOptionVisible(
+    conditions: VisibilityConditionGroup | undefined,
+    allFormElements: FormElementDto[]
+  ): boolean {
+    if (!conditions || !conditions.conditions || conditions.conditions.length === 0) {
+      return true
+    }
+    const formElementsByRef = buildFormElementsMap(allFormElements)
+    return evaluateGroup(conditions, formElementsByRef)
+  }
+
  function buildFormElementsMap(formElements: FormElementDto[]): Map<string, FormElementDto> {
    const map = new Map<string, FormElementDto>()
    formElements.forEach((element) => {
@@ -35,96 +50,104 @@ export function useFormElementVisibility() {
    return map
  }

-  /**
-   * Evaluates if an element is visible based on its visibility conditions.
-   * Multiple conditions use AND logic - all conditions must be met for the element to be visible.
-   */
  function isElementVisible(element: FormElementDto, formElementsByRef: Map<string, FormElementDto>): boolean {
-    const conditions = element.visibilityConditions
-    if (!conditions || conditions.length === 0) {
+    const group = element.visibilityConditions
+    if (!group || !group.conditions || group.conditions.length === 0) {
      return true
    }

-    // All conditions must be met (AND logic)
-    return conditions.every((condition) => evaluateSingleCondition(condition, formElementsByRef))
+    return evaluateGroup(group, formElementsByRef)
  }

-  /**
-   * Evaluates a single visibility condition against the form state.
-   */
-  function evaluateSingleCondition(
-    condition: FormElementVisibilityCondition,
+  function evaluateGroup(group: VisibilityConditionGroup, formElementsByRef: Map<string, FormElementDto>): boolean {
+    if (!group.conditions || group.conditions.length === 0) {
+      return true
+    }
+    const results = group.conditions.map((c) => evaluateNode(c, formElementsByRef))
+    return group.operator === VCGroupOperatorEnum.And ? results.every(Boolean) : results.some(Boolean)
+  }
+
+  function evaluateNode(node: VisibilityConditionNode, formElementsByRef: Map<string, FormElementDto>): boolean {
+    if (node.nodeType === VCNodeTypeEnum.Group) {
+      return evaluateNodeGroup(node, formElementsByRef)
+    }
+    return evaluateLeafCondition(node, formElementsByRef)
+  }
+
+  function evaluateNodeGroup(node: VisibilityConditionNode, formElementsByRef: Map<string, FormElementDto>): boolean {
+    if (!node.conditions || node.conditions.length === 0) {
+      return true
+    }
+    const results = node.conditions.map((c) => evaluateNode(c, formElementsByRef))
+    return node.groupOperator === VCNodeGroupOperatorEnum.And ? results.every(Boolean) : results.some(Boolean)
+  }
+
+  function evaluateLeafCondition(
+    leaf: VisibilityConditionNode,
    formElementsByRef: Map<string, FormElementDto>
  ): boolean {
-    const sourceElement = formElementsByRef.get(condition.sourceFormElementReference)
+    if (!leaf.sourceFormElementReference) {
+      return false
+    }
+    const sourceElement = formElementsByRef.get(leaf.sourceFormElementReference)
    if (!sourceElement) {
      return false
    }

    // Special handling for CHECKBOX with multiple options
    if (sourceElement.type === FormElementType.Checkbox && sourceElement.options.length > 1) {
-      const operator = condition.formElementOperator || VCOperator.Equals
-      const conditionMet = evaluateCheckboxCondition(sourceElement, condition.formElementExpectedValue || '', operator)
-      return condition.formElementConditionType === VCType.Show ? conditionMet : !conditionMet
+      const operator = leaf.formElementOperator || VCOperator.Equals
+      const conditionMet = evaluateCheckboxCondition(sourceElement, leaf.formElementExpectedValue || '', operator)
+      return leaf.formElementConditionType === VCType.Hide ? !conditionMet : conditionMet
    }

    const sourceValue = getFormElementValue(sourceElement)
-    const operator = condition.formElementOperator || VCOperator.Equals
-    const conditionMet = evaluateCondition(sourceValue, condition.formElementExpectedValue || '', operator)
+    const operator = leaf.formElementOperator || VCOperator.Equals
+    const conditionMet = evaluateCondition(sourceValue, leaf.formElementExpectedValue || '', operator)

-    return condition.formElementConditionType === VCType.Show ? conditionMet : !conditionMet
+    return leaf.formElementConditionType === VCType.Hide ? !conditionMet : conditionMet
  }

  function getFormElementValue(element: FormElementDto): string {
-    // For CHECKBOX with a single option, return the value directly
    if (element.type === FormElementType.Checkbox && element.options.length === 1) {
      return element.options[0]?.value || ''
    }

-    // For other element types (RADIOBUTTON, SELECT, etc.), find the selected option and return its label
    const selectedOption = element.options.find((option) => option.value === 'true')
    return selectedOption?.label || ''
  }

-  /**
-   * Evaluates visibility condition for CHECKBOX with multiple options.
-   * Checks if ANY of the selected checkboxes matches the expected value.
-   */
-  function evaluateCheckboxCondition(
-    element: FormElementDto,
-    expectedValue: string,
-    operator: VisibilityConditionOperator
-  ): boolean {
+  function evaluateCheckboxCondition(element: FormElementDto, expectedValue: string, operator: string): boolean {
    const selectedLabels = element.options.filter((option) => option.value === 'true').map((option) => option.label)

    switch (operator) {
      case VCOperator.Equals:
-        // Check if any selected checkbox label matches the expected value
        return selectedLabels.some((label) => label.toLowerCase() === expectedValue.toLowerCase())
      case VCOperator.NotEquals:
-        // Check if no selected checkbox label matches the expected value
+        return !selectedLabels.some((label) => label.toLowerCase() === expectedValue.toLowerCase())
+      case VCOperator.Contains:
+        return selectedLabels.some((label) => label.toLowerCase() === expectedValue.toLowerCase())
+      case VCOperator.NotContains:
        return !selectedLabels.some((label) => label.toLowerCase() === expectedValue.toLowerCase())
      case VCOperator.IsEmpty:
-        // Check if no checkboxes are selected
        return selectedLabels.length === 0
      case VCOperator.IsNotEmpty:
-        // Check if at least one checkbox is selected
        return selectedLabels.length > 0
      default:
        return false
    }
  }

-  function evaluateCondition(
-    actualValue: string,
-    expectedValue: string,
-    operator: VisibilityConditionOperator
-  ): boolean {
+  function evaluateCondition(actualValue: string, expectedValue: string, operator: string): boolean {
    switch (operator) {
      case VCOperator.Equals:
        return actualValue.toLowerCase() === expectedValue.toLowerCase()
      case VCOperator.NotEquals:
        return actualValue.toLowerCase() !== expectedValue.toLowerCase()
+      case VCOperator.Contains:
+        return actualValue.toLowerCase().includes(expectedValue.toLowerCase())
+      case VCOperator.NotContains:
+        return !actualValue.toLowerCase().includes(expectedValue.toLowerCase())
      case VCOperator.IsEmpty:
        return actualValue === ''
      case VCOperator.IsNotEmpty:
@@ -135,6 +158,7 @@ export function useFormElementVisibility() {
  }

  return {
-    evaluateFormElementVisibility
+    evaluateFormElementVisibility,
+    isFormOptionVisible
  }
 }