feat: Add version_of and matches to rules and conditions

api/pyproject.toml

@@ -170,7 +170,7 @@ hubspot-api-client = "^8.2.1"
 djangorestframework-dataclasses = "^1.3.1"
 pyotp = "^2.9.0"
 flagsmith-task-processor = { git = "https://github.com/Flagsmith/flagsmith-task-processor", tag = "v1.2.0" }
-flagsmith-common = { git = "https://github.com/Flagsmith/flagsmith-common", tag = "v1.4.2" }
+flagsmith-common = { git = "https://github.com/Flagsmith/flagsmith-common", branch = "feat/add_version_of_to_rules_and_conditions" }
 tzdata = "^2024.1"
 djangorestframework-simplejwt = "^5.3.1"
 structlog = "^24.4.0"
@@ -197,7 +197,7 @@ flagsmith-ldap = { git = "https://github.com/flagsmith/flagsmith-ldap", tag = "v
 optional = true
 
 [tool.poetry.group.workflows.dependencies]
-workflows-logic = { git = "https://github.com/flagsmith/flagsmith-workflows", tag = "v2.7.5" }
+workflows-logic = { git = "https://github.com/flagsmith/flagsmith-workflows", branch = "feat/add_matches_to_workflows" }
 
 [tool.poetry.group.licensing]
 optional = true

api/segments/migrations/0027_version_rules_and_conditions.py

@@ -0,0 +1,48 @@
+# Generated by Django 4.2.17 on 2025-01-08 15:21
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("segments", "0026_add_change_request_to_segments"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="condition",
+            name="version_of",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="versioned_conditions",
+                to="segments.condition",
+            ),
+        ),
+        migrations.AddField(
+            model_name="historicalcondition",
+            name="version_of",
+            field=models.ForeignKey(
+                blank=True,
+                db_constraint=False,
+                null=True,
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="segments.condition",
+            ),
+        ),
+        migrations.AddField(
+            model_name="segmentrule",
+            name="version_of",
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="versioned_rules",
+                to="segments.segmentrule",
+            ),
+        ),
+    ]

api/segments/models.py

@@ -198,6 +198,76 @@ def deep_clone(self) -> "Segment":
 
         return cloned_segment
 
+    def assign_matching_rules_to_segment(self, segment: "Segment") -> bool:
+        """
+        Assign matching rules of the current object to the rules of the given segment.
+
+        This method iterates through the rules of the provided `Segment` and
+        attempts to match them to the current object's rules and sub-rules,
+        updating versioning where matches are found.
+
+        This is done in order to set the `version_of` field for matched rules
+        and conditions so that the frontend can more reliably diff rules and
+        conditions between a change request for a segment and the target segment
+        itself.
+
+        Args:
+            segment (Segment): The segment whose rules are being matched
+                               against the current object's rules.
+
+        Returns:
+            bool:
+                - `True` if any rules or sub-rules match between the current
+                  object and the segment.
+                - `False` if no matches are found.
+
+        Process:
+            1. Retrieve all rules associated with the current object and the segment.
+            2. For each rule in the segment:
+               - Check its sub-rules against the current object's rules and sub-rules.
+               - A match is determined if the sub-rule's type and properties align
+                 with those of the current object's sub-rules.
+               - If a match is found:
+                 - Update the `version_of` field for the matched sub-rule and rule.
+                 - Track the matched rules and sub-rules to avoid duplicate processing.
+            3. Perform a bulk update on matched rules and sub-rules to persist
+               versioning changes.
+
+        Side Effects:
+            - Updates the `version_of` field for matched rules and sub-rules.
+        """
+
+        self_rules = self.rules.all()
+        matched_rules = set()
+        matched_sub_rules = set()
+
+        for rule in segment.rules.all():
+            for sub_rule in rule.rules.all():
+                sub_rule_matched = False
+                for self_rule in self_rules:
+                    if sub_rule_matched:
+                        break
+
+                    if self_rule in matched_rules and self_rule.version_of != rule:
+                        continue
+
+                    if rule.type != self_rule.type:
+                        continue
+                    for self_sub_rule in self_rule.rules.all():
+                        if self_sub_rule in matched_sub_rules:
+                            continue
+                        if self_sub_rule.assign_conditions_if_matching_rule(sub_rule):
+                            self_sub_rule.version_of = sub_rule
+                            sub_rule_matched = True
+                            matched_sub_rules.add(self_sub_rule)
+                            self_rule.version_of = rule
+                            matched_rules.add(self_rule)
+                            break
+        SegmentRule.objects.bulk_update(
+            matched_rules | matched_sub_rules, fields=["version_of"]
+        )
+        return bool(matched_rules | matched_sub_rules)
+
     def get_create_log_message(self, history_instance) -> typing.Optional[str]:
         return SEGMENT_CREATED_MESSAGE % self.name
 
@@ -224,6 +294,13 @@ class SegmentRule(SoftDeleteExportableModel):
     rule = models.ForeignKey(
         "self", on_delete=models.CASCADE, related_name="rules", null=True, blank=True
     )
+    version_of = models.ForeignKey(
+        "self",
+        on_delete=models.SET_NULL,
+        related_name="versioned_rules",
+        null=True,
+        blank=True,
+    )
 
     type = models.CharField(max_length=50, choices=RULE_TYPES)
 
@@ -261,13 +338,74 @@ def get_segment(self):
             rule = rule.rule
         return rule.segment
 
+    def assign_conditions_if_matching_rule(self, rule: "SegmentRule") -> bool:
+        """
+        Determines whether the current object matches the given rule
+        and assigns conditions with the `version_of` field.
+
+        These assignments are done in order to allow the frontend to
+        provide a diff capability during change requests for segments.
+        By knowing which version a condition is for the frontend can
+        show a more accurate diff between the segment and the change request.
+
+        This method compares the type and conditions of the current object with
+        the specified `SegmentRule` to determine if they are compatible.
+
+        Returns:
+            bool:
+                - `True` if the current object's type matches the rule's type
+                  and the conditions are compatible.
+                - `False` if the types do not match or no conditions are compatible.
+
+        Process:
+            1. If the types do not match, return `False`.
+            2. If both the rule and current object have no conditions, return `True`.
+            3. Compare each condition in the rule against the current object's conditions:
+               - A condition matches if both `operator` and `property` are equal.
+               - Mark matched conditions and update the versioning.
+            4. Return `True` if at least one condition matches; otherwise, return `False`.
+
+        Side Effects:
+            Updates the `version_of` field for matched conditions using a bulk update.
+        """
+
+        if rule.type != self.type:
+            return False
+
+        conditions = rule.conditions.all()
+        self_conditions = self.conditions.all()
+
+        if not conditions and not self_conditions:
+            # Empty rule with the same type matches.
+            return True
+
+        matched_conditions = set()
+
+        for condition in conditions:
+            for self_condition in self_conditions:
+                if self_condition in matched_conditions:
+                    continue
+                if (
+                    condition.operator == self_condition.operator
+                    and condition.property == self_condition.property
+                ):
+                    matched_conditions.add(self_condition)
+                    self_condition.version_of = condition
+                    break
+        if not matched_conditions:
+            return False
+
+        Condition.objects.bulk_update(matched_conditions, fields=["version_of"])
+        return True
+
     def deep_clone(self, cloned_segment: Segment) -> "SegmentRule":
         if self.rule:
             # Since we're expecting a rule that is only belonging to a
             # segment, since a rule either belongs to a segment xor belongs
             # to a rule, we don't expect there also to be a rule associated.
             assert False, "Unexpected rule, expecting segment set not rule"
         cloned_rule = deepcopy(self)
+        cloned_rule.version_of = self
         cloned_rule.segment = cloned_segment
         cloned_rule.uuid = uuid.uuid4()
         cloned_rule.id = None
@@ -284,6 +422,7 @@ def deep_clone(self, cloned_segment: Segment) -> "SegmentRule":
                 assert False, "Expected two layers of rules, not more"
 
             cloned_sub_rule = deepcopy(sub_rule)
+            cloned_sub_rule.version_of = sub_rule
             cloned_sub_rule.rule = cloned_rule
             cloned_sub_rule.uuid = uuid.uuid4()
             cloned_sub_rule.id = None
@@ -296,6 +435,7 @@ def deep_clone(self, cloned_segment: Segment) -> "SegmentRule":
             cloned_conditions = []
             for condition in sub_rule.conditions.all():
                 cloned_condition = deepcopy(condition)
+                cloned_condition.version_of = condition
                 cloned_condition.rule = cloned_sub_rule
                 cloned_condition.uuid = uuid.uuid4()
                 cloned_condition.id = None
@@ -348,6 +488,13 @@ class Condition(
     rule = models.ForeignKey(
         SegmentRule, on_delete=models.CASCADE, related_name="conditions"
     )
+    version_of = models.ForeignKey(
+        "self",
+        on_delete=models.SET_NULL,
+        related_name="versioned_conditions",
+        null=True,
+        blank=True,
+    )
 
     created_at = models.DateTimeField(null=True, auto_now_add=True)
     updated_at = models.DateTimeField(null=True, auto_now=True)